@powerhousedao/service-offering 1.0.0-dev.4 → 1.0.0-dev.5

package/dist/subgraphs/resources-services/resolvers.js

@@ -1,44 +1,53 @@
-import { BaseSubgraph } from "@powerhousedao/reactor-api";
-import { createAction, generateId } from "document-model/core";
-import { addFile } from "document-drive";
-import { ResourceInstanceV1, SubscriptionInstanceV1, } from "@powerhousedao/service-offering/document-models";
+import { getUserSelectionPriceBreakdown, } from "@powerhousedao/service-offering/document-models/service-offering";
+import { createAction } from "document-model/core";
+import { addFile, driveCreateDocument } from "document-drive";
+import { ResourceInstanceV1 as ResourceInstance, SubscriptionInstanceV1 as SubscriptionInstance, } from "@powerhousedao/service-offering/document-models";
+import { mapOfferingToSubscription } from "../../editors/subscription-instance-editor/components/mapOfferingToSubscription.js";
 export const getResolvers = (subgraph) => {
-    const reactor = subgraph.reactor;
     const reactorClient = subgraph.reactorClient;
     return {
         Query: {
             resourceTemplates: async (_, args) => {
                 const { id, status, operatorId } = args.filter || {};
-                // If filtering by specific id, fetch directly
+                // If filtering by specific id, try to fetch directly
                 if (id) {
                     try {
-                        const result = await reactorClient.find({ type: "powerhouse/resource-template", ids: [id] });
-                        const docs = result.results;
-                        if (docs.length === 0)
-                            return [];
-                        const doc = docs[0];
-                        const state = doc.state.global;
-                        if (status && status.length > 0 && !status.includes(state.status)) {
-                            return [];
+                        const doc = await reactorClient.get(id);
+                        if (doc &&
+                            doc.header.documentType === "powerhouse/resource-template") {
+                            const state = doc.state.global;
+                            if (status &&
+                                status.length > 0 &&
+                                !status.includes(state.status)) {
+                                return [];
+                            }
+                            if (operatorId && state.operatorId !== operatorId) {
+                                return [];
+                            }
+                            return [mapResourceTemplateState(state, doc)];
                         }
-                        if (operatorId && state.operatorId !== operatorId) {
-                            return [];
-                        }
-                        return [mapResourceTemplateState(state, doc)];
                     }
                     catch {
-                        return [];
+                        // Document not found
                     }
+                    return [];
                 }
                 // Find all resource template documents
-                const result = await reactorClient.find({ type: "powerhouse/resource-template" });
-                const docs = result.results;
+                const { results: docs } = await reactorClient.find({
+                    type: "powerhouse/resource-template",
+                });
                 const resourceTemplates = [];
                 for (const doc of docs) {
-                    const state = doc.state.global;
+                    const resourceDoc = doc;
+                    const state = resourceDoc.state.global;
+                    // Skip documents missing required fields
+                    if (!state.operatorId)
+                        continue;
+                    // Apply status filter if provided
                     if (status && status.length > 0 && !status.includes(state.status)) {
                         continue;
                     }
+                    // Apply operatorId filter if provided
                     if (operatorId && state.operatorId !== operatorId) {
                         continue;
                     }
@@ -48,43 +57,53 @@ export const getResolvers = (subgraph) => {
             },
             serviceOfferings: async (_, args) => {
                 const { id, status, operatorId, resourceTemplateId } = args.filter || {};
-                // If filtering by specific id, fetch directly
+                // If filtering by specific id, try to fetch directly
                 if (id) {
                     try {
-                        const result = await reactorClient.find({ type: "powerhouse/service-offering", ids: [id] });
-                        const docs = result.results;
-                        if (docs.length === 0)
-                            return [];
-                        const doc = docs[0];
-                        const state = doc.state.global;
-                        if (status && status.length > 0 && !status.includes(state.status)) {
-                            return [];
-                        }
-                        if (operatorId && state.operatorId !== operatorId) {
-                            return [];
+                        const doc = await reactorClient.get(id);
+                        if (doc &&
+                            doc.header.documentType === "powerhouse/service-offering") {
+                            const state = doc.state.global;
+                            if (status &&
+                                status.length > 0 &&
+                                !status.includes(state.status)) {
+                                return [];
+                            }
+                            if (operatorId && state.operatorId !== operatorId) {
+                                return [];
+                            }
+                            if (resourceTemplateId &&
+                                state.resourceTemplateId !== resourceTemplateId) {
+                                return [];
+                            }
+                            return [mapServiceOfferingState(state, doc)];
                         }
-                        if (resourceTemplateId &&
-                            state.resourceTemplateId !== resourceTemplateId) {
-                            return [];
-                        }
-                        return [mapServiceOfferingState(state, doc)];
                     }
                     catch {
-                        return [];
+                        // Document not found
                     }
+                    return [];
                 }
                 // Find all service offering documents
-                const result = await reactorClient.find({ type: "powerhouse/service-offering" });
-                const docs = result.results;
+                const { results: docs } = await reactorClient.find({
+                    type: "powerhouse/service-offering",
+                });
                 const serviceOfferings = [];
                 for (const doc of docs) {
-                    const state = doc.state.global;
+                    const offeringDoc = doc;
+                    const state = offeringDoc.state.global;
+                    // Skip documents missing required fields
+                    if (!state.operatorId)
+                        continue;
+                    // Apply status filter if provided
                     if (status && status.length > 0 && !status.includes(state.status)) {
                         continue;
                     }
+                    // Apply operatorId filter if provided
                     if (operatorId && state.operatorId !== operatorId) {
                         continue;
                     }
+                    // Apply resourceTemplateId filter if provided
                     if (resourceTemplateId &&
                         state.resourceTemplateId !== resourceTemplateId) {
                         continue;
@@ -175,7 +194,7 @@ export const getResolvers = (subgraph) => {
                     };
                 }
                 // Fetch the service offering
-                const serviceOfferingDoc = await reactor.getDocument(serviceOfferingId);
+                const serviceOfferingDoc = await reactorClient.get(serviceOfferingId);
                 if (!serviceOfferingDoc) {
                     return {
                         success: false,
@@ -192,13 +211,38 @@ export const getResolvers = (subgraph) => {
                         errors: ["Service offering has no associated resource template"],
                     };
                 }
-                // Find the selected tier
-                const selectedTier = serviceOfferingState.tiers.find((t) => t.id === userSelection.tierId);
-                if (!selectedTier) {
+                // Convert GraphQL overrides to Record<string, BillingCycle>
+                const groupBillingCycleOverrides = {};
+                for (const o of userSelection.groupBillingCycleOverrides ?? []) {
+                    groupBillingCycleOverrides[o.groupId] =
+                        o.billingCycle;
+                }
+                const addonBillingCycleOverrides = {};
+                for (const o of userSelection.addonBillingCycleOverrides ?? []) {
+                    addonBillingCycleOverrides[o.groupId] =
+                        o.billingCycle;
+                }
+                // Compute price breakdown from user selection
+                const selection = {
+                    tierId: userSelection.tierId,
+                    billingCycle: userSelection.billingCycle,
+                    optionGroupIds: userSelection.optionGroupIds ?? [],
+                    groupBillingCycleOverrides,
+                    addonBillingCycleOverrides,
+                };
+                let priceBreakdown;
+                try {
+                    priceBreakdown = getUserSelectionPriceBreakdown(serviceOfferingDoc.state, selection);
+                }
+                catch (error) {
                     return {
                         success: false,
                         data: null,
-                        errors: ["Selected tier not found in service offering"],
+                        errors: [
+                            error instanceof Error
+                                ? error.message
+                                : "Failed to compute price breakdown from user selection",
+                        ],
                     };
                 }
                 // Sanitize names for use as drive id/slug: lowercase, trim, collapse whitespace, replace spaces with hyphens
@@ -207,36 +251,36 @@ export const getResolvers = (subgraph) => {
                     .toLowerCase()
                     .replace(/\s+/g, "-")
                     .replace(/_/g, "-");
-                const parsedName = name
-                    .trim()
-                    .toLowerCase()
-                    .replace(/\s+/g, "-")
-                    .replace(/_/g, "-");
                 try {
                     // create team-builder-admin drive
-                    const teamBuilderAdminDrive = await reactor.addDrive({
-                        global: {
-                            name: teamName,
-                            icon: "https://cdn-icons-png.flaticon.com/512/6020/6020347.png",
-                        },
-                        id: generateId(),
-                        slug: parsedTeamName,
-                        preferredEditor: "builder-team-admin",
-                    });
+                    const driveDoc = driveCreateDocument();
+                    driveDoc.state.global.name = teamName;
+                    driveDoc.state.global.icon =
+                        "https://cdn-icons-png.flaticon.com/512/6020/6020347.png";
+                    driveDoc.header.slug = parsedTeamName;
+                    if (!driveDoc.header.meta)
+                        driveDoc.header.meta = {};
+                    driveDoc.header.meta.preferredEditor = "builder-team-admin";
+                    const teamBuilderAdminDrive = await reactorClient.create(driveDoc);
                     // create builder-profile doc inside the team-builder-admin drive
-                    const builderProfileDoc = await reactor.addDocument("powerhouse/builder-profile");
-                    await reactor.addAction(teamBuilderAdminDrive.header.id, addFile({
-                        documentType: "powerhouse/builder-profile",
-                        id: builderProfileDoc.header.id,
-                        name: `${parsedTeamName} Builder Profile`,
-                        parentFolder: teamBuilderAdminDrive.state.global.nodes?.find((node) => node.kind === "folder")?.parentFolder,
-                    }));
-                    await reactor.addAction(builderProfileDoc.header.id, createAction("UPDATE_PROFILE", { name: parsedTeamName }, undefined, undefined, "global"));
+                    const builderProfileDoc = await reactorClient.createEmpty("powerhouse/builder-profile");
+                    const teamRootFolder = teamBuilderAdminDrive.state.global.nodes.find((node) => node.kind === "folder")?.parentFolder;
+                    await reactorClient.execute(teamBuilderAdminDrive.header.id, "main", [
+                        addFile({
+                            documentType: "powerhouse/builder-profile",
+                            id: builderProfileDoc.header.id,
+                            name: `${parsedTeamName} Builder Profile`,
+                            parentFolder: teamRootFolder,
+                        }),
+                    ]);
+                    await reactorClient.execute(builderProfileDoc.header.id, "main", [
+                        createAction("UPDATE_PROFILE", { name: parsedTeamName }, undefined, undefined, "global"),
+                    ]);
                     // create resource-instance and subscription-instance docs
-                    const resourceInstanceDoc = await reactor.addDocument("powerhouse/resource-instance");
-                    const subscriptionInstanceDoc = await reactor.addDocument("powerhouse/subscription-instance");
+                    const resourceInstanceDoc = await reactorClient.createEmpty("powerhouse/resource-instance");
+                    const subscriptionInstanceDoc = await reactorClient.createEmpty("powerhouse/subscription-instance");
                     // resolve parent folders for both drives
-                    const teamParentFolder = teamBuilderAdminDrive.state.global.nodes?.find((node) => node.kind === "folder")?.parentFolder;
+                    const teamParentFolder = teamBuilderAdminDrive.state.global.nodes.find((node) => node.kind === "folder")?.parentFolder;
                     const operatorDrive = await getOperatorDrive(reactorClient, resourceTemplateId);
                     if (!operatorDrive) {
                         throw new Error(`Operator drive not found for resource template ${resourceTemplateId}`);
@@ -250,7 +294,7 @@ export const getResolvers = (subgraph) => {
                     }
                     const operatorParentFolder = operatorDrive.state.global.nodes.find((node) => node.kind === "folder")?.parentFolder;
                     // batch add resource-instance and subscription-instance to team-builder-admin drive
-                    await reactor.addActions(teamBuilderAdminDrive.header.id, [
+                    await reactorClient.execute(teamBuilderAdminDrive.header.id, "main", [
                         addFile({
                             documentType: "powerhouse/resource-instance",
                             id: resourceInstanceDoc.header.id,
@@ -265,7 +309,7 @@ export const getResolvers = (subgraph) => {
                         }),
                     ]);
                     // batch add resource-instance and subscription-instance to operator drive
-                    await reactor.addActions(operatorDrive.header.id, [
+                    await reactorClient.execute(operatorDrive.header.id, "main", [
                         addFile({
                             documentType: "powerhouse/resource-instance",
                             id: resourceInstanceDoc.header.id,
@@ -280,30 +324,37 @@ export const getResolvers = (subgraph) => {
                         }),
                     ]);
                     // populate documents after all files are added to both drives
-                    await populateResourceInstance(reactor, resourceInstanceDoc.header.id, resourceTemplateId, operatorProfileId, // operator profile id
+                    await populateResourceInstance(reactorClient, resourceInstanceDoc.header.id, resourceTemplateId, operatorProfileId, // operator profile id
                     builderProfileDoc.header.id, // customer id
                     parsedTeamName);
                     const now = new Date().toISOString();
-                    await reactor.addAction(subscriptionInstanceDoc.header.id, SubscriptionInstanceV1.actions.initializeSubscription({
-                        createdAt: now,
+                    const subscriptionInput = mapOfferingToSubscription({
+                        offering: serviceOfferingState,
+                        tierId: selection.tierId,
+                        selectedBillingCycle: selection.billingCycle,
                         customerId: builderProfileDoc.header.id,
                         customerName: name,
                         customerEmail,
-                        serviceOfferingId,
-                        tierName: selectedTier.name,
-                        tierPricingOptionId: selectedTier.id,
-                        tierPrice: selectedTier.pricing?.amount ?? undefined,
-                        tierCurrency: selectedTier.pricing?.currency ?? "USD",
-                        tierPricingMode: selectedTier.pricingMode,
-                        selectedBillingCycle: userSelection.billingCycle,
-                        globalCurrency: selectedTier.pricing?.currency ?? "USD",
-                    }));
-                    const projectedAmount = selectedTier.pricing?.amount;
+                        createdAt: now,
+                        priceBreakdown,
+                    });
+                    await reactorClient.execute(subscriptionInstanceDoc.header.id, "main", [
+                        SubscriptionInstance.actions.initializeSubscription({
+                            ...subscriptionInput,
+                            resourceId: resourceInstanceDoc.header.id,
+                            resourceLabel: parsedTeamName,
+                            resourceThumbnailUrl: serviceOfferingState.thumbnailUrl,
+                        }),
+                    ]);
+                    // Set billing projection from tier price
+                    const projectedAmount = subscriptionInput.tierPrice ?? priceBreakdown.tierCycleTotal;
                     if (projectedAmount != null) {
-                        await reactor.addAction(subscriptionInstanceDoc.header.id, SubscriptionInstanceV1.actions.updateBillingProjection({
-                            projectedBillAmount: projectedAmount,
-                            projectedBillCurrency: selectedTier.pricing?.currency || "USD",
-                        }));
+                        await reactorClient.execute(subscriptionInstanceDoc.header.id, "main", [
+                            SubscriptionInstance.actions.updateBillingProjection({
+                                projectedBillAmount: projectedAmount,
+                                projectedBillCurrency: priceBreakdown.tierCurrency || "USD",
+                            }),
+                        ]);
                     }
                     return {
                         success: true,
@@ -334,7 +385,7 @@ export const getResolvers = (subgraph) => {
  * Uses the drive slug in the switchboard URL path.
  */
 function getDriveLink(driveSlug) {
-    const baseUri = process.env.BASE_URI || "";
+    const baseUri = typeof process !== "undefined" ? process.env.BASE_URI || "" : "";
     if (baseUri.includes("-dev.")) {
         return `https://connect-dev.powerhouse.xyz/?driveUrl=https://switchboard-dev.powerhouse.xyz/d/${driveSlug}`;
     }
@@ -360,18 +411,18 @@ function mapResourceTemplateState(state, doc) {
         infoLink: state.infoLink || null,
         status: state.status,
         lastModified: state.lastModified,
-        targetAudiences: state.targetAudiences.map((audience) => ({
+        targetAudiences: (state.targetAudiences || []).map((audience) => ({
             id: audience.id,
             label: audience.label,
             color: audience.color || null,
         })),
-        setupServices: state.setupServices,
-        recurringServices: state.recurringServices,
-        facetTargets: state.facetTargets.map((facet) => ({
+        setupServices: state.setupServices || [],
+        recurringServices: state.recurringServices || [],
+        facetTargets: (state.facetTargets || []).map((facet) => ({
             id: facet.id,
             categoryKey: facet.categoryKey,
             categoryLabel: facet.categoryLabel,
-            selectedOptions: facet.selectedOptions,
+            selectedOptions: facet.selectedOptions || [],
         })),
         services: (state.services || []).map((service) => ({
             id: service.id,
@@ -385,7 +436,7 @@ function mapResourceTemplateState(state, doc) {
                 id: binding.id,
                 facetName: binding.facetName,
                 facetType: binding.facetType,
-                supportedOptions: binding.supportedOptions,
+                supportedOptions: binding.supportedOptions || [],
             })),
         })),
         optionGroups: (state.optionGroups || []).map((group) => ({
@@ -401,7 +452,7 @@ function mapResourceTemplateState(state, doc) {
             answer: faq.answer || null,
             displayOrder: faq.displayOrder,
         })),
-        contentSections: state.contentSections.map((section) => ({
+        contentSections: (state.contentSections || []).map((section) => ({
             id: section.id,
             title: section.title,
             content: section.content,
@@ -413,35 +464,50 @@ function mapResourceTemplateState(state, doc) {
  * Populate a resource-instance document with data from a resource-template.
  * Initializes basic info and sets facet configuration from template facetTargets.
  */
-async function populateResourceInstance(reactor, resourceInstanceDocId, resourceTemplateId, operatorId, customerId, customerName) {
-    const resourceTemplateDoc = await reactor.getDocument(resourceTemplateId);
+async function populateResourceInstance(reactorClient, resourceInstanceDocId, resourceTemplateId, operatorId, customerId, customerName) {
+    const resourceTemplateDoc = await reactorClient.get(resourceTemplateId);
     if (!resourceTemplateDoc)
         return;
     const templateState = resourceTemplateDoc.state.global;
     // Initialize instance with basic info from template
-    await reactor.addAction(resourceInstanceDocId, ResourceInstanceV1.actions.initializeInstance({
-        operatorId,
-        operatorDocumentType: "powerhouse/builder-profile",
-        resourceTemplateId,
-        customerId,
-        customerName,
-        templateName: templateState.title,
-        thumbnailUrl: templateState.thumbnailUrl,
-        infoLink: templateState.infoLink,
-        description: templateState.description,
-    }));
+    await reactorClient.execute(resourceInstanceDocId, "main", [
+        ResourceInstance.actions.initializeInstance({
+            operatorId,
+            operatorDocumentType: "powerhouse/builder-profile",
+            resourceTemplateId,
+            customerId,
+            customerName,
+            templateName: templateState.title,
+            thumbnailUrl: templateState.thumbnailUrl,
+            infoLink: templateState.infoLink,
+            description: templateState.description,
+        }),
+    ]);
     // Populate facet configuration from template's facetTargets
     for (const facetTarget of templateState.facetTargets) {
         if (facetTarget.selectedOptions.length > 0) {
-            await reactor.addAction(resourceInstanceDocId, ResourceInstanceV1.actions.setInstanceFacet({
-                id: facetTarget.id,
-                categoryKey: facetTarget.categoryKey,
-                categoryLabel: facetTarget.categoryLabel,
-                selectedOption: facetTarget.selectedOptions[0],
-            }));
+            await reactorClient.execute(resourceInstanceDocId, "main", [
+                ResourceInstance.actions.setInstanceFacet({
+                    id: facetTarget.id,
+                    categoryKey: facetTarget.categoryKey,
+                    categoryLabel: facetTarget.categoryLabel,
+                    selectedOption: facetTarget.selectedOptions[0],
+                }),
+            ]);
         }
     }
 }
+/**
+ * Map a DiscountRule to the GraphQL shape, or null
+ */
+function mapDiscountRule(rule) {
+    if (!rule)
+        return null;
+    return {
+        discountType: rule.discountType,
+        discountValue: rule.discountValue,
+    };
+}
 /**
  * Map ServiceOfferingState from document model to GraphQL response
  */
@@ -457,14 +523,14 @@ function mapServiceOfferingState(state, doc) {
         infoLink: state.infoLink || null,
         status: state.status,
         lastModified: state.lastModified,
-        availableBillingCycles: state.availableBillingCycles,
-        facetTargets: state.facetTargets.map((facet) => ({
+        availableBillingCycles: state.availableBillingCycles || [],
+        facetTargets: (state.facetTargets || []).map((facet) => ({
             id: facet.id,
             categoryKey: facet.categoryKey,
             categoryLabel: facet.categoryLabel,
-            selectedOptions: facet.selectedOptions,
+            selectedOptions: facet.selectedOptions || [],
         })),
-        services: state.services.map((service) => ({
+        services: (state.services || []).map((service) => ({
             id: service.id,
             title: service.title,
             description: service.description || null,
@@ -472,61 +538,102 @@ function mapServiceOfferingState(state, doc) {
             isSetupFormation: service.isSetupFormation,
             optionGroupId: service.optionGroupId || null,
         })),
-        tiers: state.tiers.map((tier) => ({
+        tiers: (state.tiers || []).map((tier) => ({
             id: tier.id,
             name: tier.name,
             description: tier.description || null,
             isCustomPricing: tier.isCustomPricing,
-            pricingMode: tier.pricingMode,
-            pricing: tier.pricing
-                ? {
-                    amount: tier.pricing.amount,
-                    currency: tier.pricing.currency,
-                }
-                : null,
+            pricingMode: tier.pricingMode || null,
+            pricing: {
+                amount: tier.pricing?.amount ?? null,
+                currency: tier.pricing?.currency ?? "USD",
+            },
             defaultBillingCycle: tier.defaultBillingCycle || null,
-            billingCycleDiscounts: tier.billingCycleDiscounts.map((d) => ({
-                cycle: d.cycle,
-                discountType: d.discountType,
-                discountValue: d.discountValue,
+            billingCycleDiscounts: (tier.billingCycleDiscounts || []).map((d) => ({
+                billingCycle: d.billingCycle,
+                discountRule: {
+                    discountType: d.discountRule?.discountType,
+                    discountValue: d.discountRule?.discountValue,
+                },
             })),
-            serviceLevels: tier.serviceLevels.map((level) => ({
+            serviceLevels: (tier.serviceLevels || []).map((level) => ({
                 id: level.id,
                 serviceId: level.serviceId,
                 level: level.level,
-                description: level.description || null,
+                customValue: level.customValue || null,
+                optionGroupId: level.optionGroupId || null,
             })),
-            usageLimits: tier.usageLimits.map((limit) => ({
+            usageLimits: (tier.usageLimits || []).map((limit) => ({
                 id: limit.id,
-                name: limit.name,
-                limit: limit.limit,
-                unit: limit.unit || null,
+                serviceId: limit.serviceId,
+                metric: limit.metric,
+                unitName: limit.unitName || null,
+                freeLimit: limit.freeLimit ?? null,
+                paidLimit: limit.paidLimit ?? null,
+                resetCycle: limit.resetCycle || null,
+                notes: limit.notes || null,
+                unitPrice: limit.unitPrice ?? null,
+                unitPriceCurrency: limit.unitPriceCurrency || null,
             })),
         })),
-        optionGroups: state.optionGroups.map((group) => ({
+        optionGroups: (state.optionGroups || []).map((group) => ({
             id: group.id,
             name: group.name,
             description: group.description || null,
             isAddOn: group.isAddOn,
             defaultSelected: group.defaultSelected,
-            pricingMode: group.pricingMode,
+            pricingMode: group.pricingMode || null,
             standalonePricing: group.standalonePricing
                 ? {
-                    amount: group.standalonePricing.amount,
-                    currency: group.standalonePricing.currency,
+                    setupCost: group.standalonePricing.setupCost
+                        ? {
+                            amount: group.standalonePricing.setupCost.amount,
+                            currency: group.standalonePricing.setupCost.currency,
+                            discount: mapDiscountRule(group.standalonePricing.setupCost.discount),
+                        }
+                        : null,
+                    recurringPricing: (group.standalonePricing.recurringPricing || []).map((rp) => ({
+                        id: rp.id,
+                        billingCycle: rp.billingCycle,
+                        amount: rp.amount,
+                        currency: rp.currency,
+                        discount: mapDiscountRule(rp.discount),
+                    })),
                 }
                 : null,
             tierDependentPricing: (group.tierDependentPricing || []).map((tp) => ({
+                id: tp.id,
                 tierId: tp.tierId,
-                amount: tp.amount,
-                currency: tp.currency,
+                setupCost: tp.setupCost
+                    ? {
+                        amount: tp.setupCost.amount,
+                        currency: tp.setupCost.currency,
+                        discount: mapDiscountRule(tp.setupCost.discount),
+                    }
+                    : null,
+                setupCostDiscounts: (tp.setupCostDiscounts || []).map((d) => ({
+                    billingCycle: d.billingCycle,
+                    discountRule: {
+                        discountType: d.discountRule?.discountType,
+                        discountValue: d.discountRule?.discountValue,
+                    },
+                })),
+                recurringPricing: (tp.recurringPricing || []).map((rp) => ({
+                    id: rp.id,
+                    billingCycle: rp.billingCycle,
+                    amount: rp.amount,
+                    currency: rp.currency,
+                    discount: mapDiscountRule(rp.discount),
+                })),
             })),
             costType: group.costType || null,
             availableBillingCycles: group.availableBillingCycles || [],
-            billingCycleDiscounts: group.billingCycleDiscounts.map((d) => ({
-                cycle: d.cycle,
-                discountType: d.discountType,
-                discountValue: d.discountValue,
+            billingCycleDiscounts: (group.billingCycleDiscounts || []).map((d) => ({
+                billingCycle: d.billingCycle,
+                discountRule: {
+                    discountType: d.discountRule?.discountType,
+                    discountValue: d.discountRule?.discountValue,
+                },
             })),
             discountMode: group.discountMode || null,
             price: group.price ?? null,
@@ -534,12 +641,19 @@ function mapServiceOfferingState(state, doc) {
         })),
     };
 }
-/**
- * Find the drive that contains a given resource template document.
- * Uses reactorClient to find the parent drive.
- */
 async function getOperatorDrive(reactorClient, resourceTemplateId) {
-    const result = await reactorClient.getParents(resourceTemplateId);
-    const parentDrive = result.results.find((doc) => doc.header.documentType === "powerhouse/document-drive");
-    return parentDrive;
+    // Find all drives
+    const { results: drives } = await reactorClient.find({
+        type: "powerhouse/document-drive",
+    });
+    for (const drive of drives) {
+        const driveDoc = drive;
+        // Check if this drive contains the resource template as a child
+        const { results: children } = await reactorClient.getChildren(driveDoc.header.id);
+        const hasTemplate = children.some((child) => child.header.id === resourceTemplateId);
+        if (hasTemplate) {
+            return driveDoc;
+        }
+    }
+    return undefined;
 }

package/dist/subgraphs/resources-services/schema.d.ts.map

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