@powerhousedao/service-offering 1.0.0-dev.1 → 1.0.0-dev.10

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

@@ -1,9 +1,11 @@
-import {} 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 "../../document-models/service-offering/v1/src/utils.js";
+import { createAction } from "document-model/core";
+import { addFile, driveCreateDocument } from "document-drive";
+import { ResourceInstance } from "../../document-models/resource-instance/v1/module.js";
+import { SubscriptionInstance } from "../../document-models/subscription-instance/v1/module.js";
+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) => {
@@ -11,17 +13,15 @@ export const getResolvers = (subgraph) => {
                 // If filtering by specific id, try to fetch directly
                 if (id) {
                     try {
-                        const doc = await reactor.getDocument(id);
+                        const doc = await reactorClient.get(id);
                         if (doc &&
                             doc.header.documentType === "powerhouse/resource-template") {
                             const state = doc.state.global;
-                            // Check status filter if provided
                             if (status &&
                                 status.length > 0 &&
                                 !status.includes(state.status)) {
                                 return [];
                             }
-                            // Check operatorId filter if provided
                             if (operatorId && state.operatorId !== operatorId) {
                                 return [];
                             }
@@ -33,42 +33,26 @@ export const getResolvers = (subgraph) => {
                     }
                     return [];
                 }
-                // Scan all drives for resource template documents
-                const drives = await reactor.getDrives();
+                // Find all resource template documents
+                const { results: docs } = await reactorClient.find({
+                    type: "powerhouse/resource-template",
+                });
                 const resourceTemplates = [];
-                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 &&
-                                doc.header.documentType === "powerhouse/resource-template") {
-                                const resourceDoc = doc;
-                                const state = resourceDoc.state.global;
-                                // 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;
-                                }
-                                resourceTemplates.push(mapResourceTemplateState(state, doc));
-                            }
-                        }
+                for (const doc of docs) {
+                    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;
                     }
-                    catch (error) {
-                        console.warn(`Failed to inspect drive ${driveId}:`, error);
+                    // Apply operatorId filter if provided
+                    if (operatorId && state.operatorId !== operatorId) {
+                        continue;
                     }
+                    resourceTemplates.push(mapResourceTemplateState(state, doc));
                 }
                 return resourceTemplates;
             },
@@ -77,21 +61,18 @@ export const getResolvers = (subgraph) => {
                 // If filtering by specific id, try to fetch directly
                 if (id) {
                     try {
-                        const doc = await reactor.getDocument(id);
+                        const doc = await reactorClient.get(id);
                         if (doc &&
                             doc.header.documentType === "powerhouse/service-offering") {
                             const state = doc.state.global;
-                            // Check status filter if provided
                             if (status &&
                                 status.length > 0 &&
                                 !status.includes(state.status)) {
                                 return [];
                             }
-                            // Check operatorId filter if provided
                             if (operatorId && state.operatorId !== operatorId) {
                                 return [];
                             }
-                            // Check resourceTemplateId filter if provided
                             if (resourceTemplateId &&
                                 state.resourceTemplateId !== resourceTemplateId) {
                                 return [];
@@ -104,47 +85,31 @@ export const getResolvers = (subgraph) => {
                     }
                     return [];
                 }
-                // Scan all drives for service offering documents
-                const drives = await reactor.getDrives();
+                // Find all service offering documents
+                const { results: docs } = await reactorClient.find({
+                    type: "powerhouse/service-offering",
+                });
                 const serviceOfferings = [];
-                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 &&
-                                doc.header.documentType === "powerhouse/service-offering") {
-                                const offeringDoc = doc;
-                                const state = offeringDoc.state.global;
-                                // 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;
-                                }
-                                serviceOfferings.push(mapServiceOfferingState(state, doc));
-                            }
-                        }
+                for (const doc of docs) {
+                    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;
                     }
-                    catch (error) {
-                        console.warn(`Failed to inspect drive ${driveId}:`, error);
+                    // Apply resourceTemplateId filter if provided
+                    if (resourceTemplateId &&
+                        state.resourceTemplateId !== resourceTemplateId) {
+                        continue;
                     }
+                    serviceOfferings.push(mapServiceOfferingState(state, doc));
                 }
                 return serviceOfferings;
             },
@@ -230,7 +195,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,
@@ -247,13 +212,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
@@ -262,37 +252,51 @@ 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",
-                    });
-                    // 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"));
-                    // create resource-instance and subscription-instance docs
-                    const resourceInstanceDoc = await reactor.addDocument("powerhouse/resource-instance");
-                    const subscriptionInstanceDoc = await reactor.addDocument("powerhouse/subscription-instance");
-                    // resolve parent folders for both drives
-                    const teamParentFolder = teamBuilderAdminDrive.state.global.nodes?.find((node) => node.kind === "folder")?.parentFolder;
-                    const operatorDrive = await getOperatorDrive(reactor, resourceTemplateId);
+                    const driveDoc = driveCreateDocument();
+                    driveDoc.header.name = teamName;
+                    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);
+                    const driveId = teamBuilderAdminDrive.header.id;
+                    // create documents as children of the drive so Connect can sync them
+                    const builderProfileDoc = await reactorClient.createEmpty("powerhouse/builder-profile", { parentIdentifier: driveId });
+                    const resourceInstanceDoc = await reactorClient.createEmpty("powerhouse/resource-instance", { parentIdentifier: driveId });
+                    const subscriptionInstanceDoc = await reactorClient.createEmpty("powerhouse/subscription-instance", { parentIdentifier: driveId });
+                    // add file references to the team drive
+                    const teamRootFolder = teamBuilderAdminDrive.state.global.nodes.find((node) => node.kind === "folder")?.parentFolder;
+                    await reactorClient.execute(driveId, "main", [
+                        addFile({
+                            documentType: "powerhouse/builder-profile",
+                            id: builderProfileDoc.header.id,
+                            name: `${parsedTeamName} Builder Profile`,
+                            parentFolder: teamRootFolder,
+                        }),
+                        addFile({
+                            documentType: "powerhouse/resource-instance",
+                            id: resourceInstanceDoc.header.id,
+                            name: `${parsedTeamName} Resource Instance`,
+                            parentFolder: teamRootFolder,
+                        }),
+                        addFile({
+                            documentType: "powerhouse/subscription-instance",
+                            id: subscriptionInstanceDoc.header.id,
+                            name: `${parsedTeamName} Subscription Instance`,
+                            parentFolder: teamRootFolder,
+                        }),
+                    ]);
+                    // update builder profile
+                    await reactorClient.execute(builderProfileDoc.header.id, "main", [
+                        createAction("UPDATE_PROFILE", { name: parsedTeamName }, undefined, undefined, "global"),
+                    ]);
+                    // find operator drive and add references there too
+                    const operatorDrive = await getOperatorDrive(reactorClient, resourceTemplateId);
                     if (!operatorDrive) {
                         throw new Error(`Operator drive not found for resource template ${resourceTemplateId}`);
                     }
@@ -304,23 +308,14 @@ export const getResolvers = (subgraph) => {
                         throw new Error(`Operator profile not found for drive ${operatorDrive.header.id}`);
                     }
                     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, [
-                        addFile({
-                            documentType: "powerhouse/resource-instance",
-                            id: resourceInstanceDoc.header.id,
-                            name: `${parsedTeamName} Resource Instance`,
-                            parentFolder: teamParentFolder,
-                        }),
-                        addFile({
-                            documentType: "powerhouse/subscription-instance",
-                            id: subscriptionInstanceDoc.header.id,
-                            name: `${parsedTeamName} Subscription Instance`,
-                            parentFolder: teamParentFolder,
-                        }),
+                    // add reactor-level relationships so Connect syncs the child documents
+                    // (createEmpty guarantees CREATE_DOCUMENT is persisted before this runs)
+                    await reactorClient.addChildren(operatorDrive.header.id, [
+                        resourceInstanceDoc.header.id,
+                        subscriptionInstanceDoc.header.id,
                     ]);
-                    // batch add resource-instance and subscription-instance to operator drive
-                    await reactor.addActions(operatorDrive.header.id, [
+                    // add file references to operator drive
+                    await reactorClient.execute(operatorDrive.header.id, "main", [
                         addFile({
                             documentType: "powerhouse/resource-instance",
                             id: resourceInstanceDoc.header.id,
@@ -335,30 +330,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,
@@ -389,7 +391,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}`;
     }
@@ -415,18 +417,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,
@@ -436,6 +438,12 @@ function mapResourceTemplateState(state, doc) {
             parentServiceId: service.parentServiceId || null,
             isSetupFormation: service.isSetupFormation,
             optionGroupId: service.optionGroupId || null,
+            facetBindings: (service.facetBindings || []).map((binding) => ({
+                id: binding.id,
+                facetName: binding.facetName,
+                facetType: binding.facetType,
+                supportedOptions: binding.supportedOptions || [],
+            })),
         })),
         optionGroups: (state.optionGroups || []).map((group) => ({
             id: group.id,
@@ -450,7 +458,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,
@@ -462,35 +470,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
  */
@@ -506,14 +529,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,
@@ -521,37 +544,45 @@ 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 || null,
-            pricing: tier.pricing
-                ? {
-                    amount: tier.pricing.amount ?? null,
-                    currency: tier.pricing.currency,
-                }
-                : 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,
+                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,
@@ -560,21 +591,55 @@ function mapServiceOfferingState(state, doc) {
             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,
@@ -582,12 +647,19 @@ function mapServiceOfferingState(state, doc) {
         })),
     };
 }
-async function getOperatorDrive(reactor, resourceTemplateId) {
-    const drives = await reactor.getDrives();
-    const results = await Promise.all(drives.map(async (drive) => {
-        const docIds = await reactor.getDocuments(drive);
-        return docIds.includes(resourceTemplateId) ? drive : null;
-    }));
-    const driveId = results.find((id) => id !== null);
-    return driveId ? reactor.getDrive(driveId) : undefined;
+async function getOperatorDrive(reactorClient, resourceTemplateId) {
+    // 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;
 }