@lukoweb/apitogo 0.1.134 → 0.1.136

package/dist/cli/cli.js

@@ -5809,7 +5809,7 @@ import {
 // package.json
 var package_default = {
   name: "@lukoweb/apitogo",
-  version: "0.1.134",
+  version: "0.1.136",
   type: "module",
   sideEffects: [
     "**/*.css",
@@ -11252,16 +11252,16 @@ var PlatformApiClient = class {
       }
     );
   }
-  /** Check every plan at once without persisting; returns all errors in one response. */
-  validateGatewayPlans(projectId, plans) {
-    return this.request(
-      "POST",
-      `/api/v1/projects/${projectId}/gateway/plans/validate`,
-      {
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ plans })
-      }
-    );
+  /**
+   * Check every plan at once without persisting. Without `projectId` (site not deployed yet)
+   * the project-less endpoint is used; `planTier` overrides the tier used for paid-plan checks.
+   */
+  validateGatewayPlans(plans, options = {}) {
+    const path73 = options.projectId ? `/api/v1/projects/${options.projectId}/gateway/plans/validate` : "/api/v1/gateway/plans/validate";
+    return this.request("POST", path73, {
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ plans, planTier: options.planTier })
+    });
   }
   getGatewayPlan(projectId, planId) {
     return this.request(
@@ -16816,6 +16816,73 @@ var config_default = {
 // src/cli/apply/handler.ts
 import path63 from "node:path";
 
+// src/cli/platform/helpers/gateway-plan-validation.ts
+init_gateway_limits();
+function buildGatewayPlansValidationRequest(plans) {
+  return plans.map((plan, index) => {
+    const currency = tryNormalizePriceCurrency(plan.priceCurrency);
+    return {
+      sku: plan.sku?.trim() ?? "",
+      displayName: plan.displayName?.trim() ?? "",
+      limitsJson: planLimitsForPlatform(plan) ?? null,
+      includedActionKeys: plan.includedActionKeys ?? [],
+      priceAmount: plan.priceAmount ?? 0,
+      pricingModel: plan.pricingModel ?? "fixed",
+      priceLabel: plan.priceLabel,
+      priceCurrency: currency.ok ? currency.value : plan.priceCurrency ?? "",
+      billingPeriod: normalizeBillingPeriod2(plan.billingPeriod),
+      sortOrder: index
+    };
+  });
+}
+function toConfigIssue(issue) {
+  return {
+    ...issue,
+    field: issue.field.replace(/\.limitsJson$/, ".limits")
+  };
+}
+function formatGatewayPlanIssue(issue) {
+  const sku = issue.sku ? ` (${issue.sku})` : "";
+  return `${issue.field}${sku}: ${issue.message}`;
+}
+async function checkGatewayPlansOnPlatform(client, args) {
+  let result;
+  try {
+    result = await client.validateGatewayPlans(
+      buildGatewayPlansValidationRequest(args.plans),
+      { projectId: args.projectId, planTier: args.planTier }
+    );
+  } catch (error) {
+    if (error instanceof PlatformApiError && (error.status === 404 || error.status === 405)) {
+      return null;
+    }
+    throw error;
+  }
+  return {
+    errors: result.errors.map(toConfigIssue),
+    warnings: result.warnings.map(toConfigIssue)
+  };
+}
+async function assertGatewayPlansValidForPublish(client, args) {
+  const check2 = await checkGatewayPlansOnPlatform(client, args);
+  if (!check2 || check2.errors.length === 0) {
+    return { blocked: false };
+  }
+  const { errors, warnings } = check2;
+  return {
+    blocked: true,
+    payload: {
+      status: "blocked",
+      reason: "gateway_plans_invalid",
+      ...args.projectId ? { projectId: args.projectId } : {},
+      errors,
+      warnings,
+      userMessage: `Deploy is blocked: apitogo.config.json has ${errors.length} plan ${errors.length === 1 ? "error" : "errors"}.`,
+      nextStep: "Fix every issue listed in errors in apitogo.config.json plans, then retry publish."
+    }
+  };
+}
+
 // src/cli/platform/helpers/progress.ts
 var RECENT_JOB_MESSAGE_LIMIT = 5;
 function recentJobMessages(messages) {
@@ -17738,67 +17805,6 @@ async function upsertGatewayPlansFromManifest(client, config2, projectId, plans,
   return results;
 }
 
-// src/cli/platform/helpers/gateway-plan-validation.ts
-init_gateway_limits();
-function buildGatewayPlansValidationRequest(plans) {
-  return plans.map((plan, index) => {
-    const currency = tryNormalizePriceCurrency(plan.priceCurrency);
-    return {
-      sku: plan.sku?.trim() ?? "",
-      displayName: plan.displayName?.trim() ?? "",
-      limitsJson: planLimitsForPlatform(plan) ?? null,
-      includedActionKeys: plan.includedActionKeys,
-      priceAmount: plan.priceAmount ?? 0,
-      pricingModel: plan.pricingModel ?? "fixed",
-      priceLabel: plan.priceLabel,
-      priceCurrency: currency.ok ? currency.value : plan.priceCurrency ?? "",
-      billingPeriod: normalizeBillingPeriod2(plan.billingPeriod),
-      sortOrder: index
-    };
-  });
-}
-function toConfigIssue(issue) {
-  return {
-    ...issue,
-    field: issue.field.replace(/\.limitsJson$/, ".limits")
-  };
-}
-function formatGatewayPlanIssue(issue) {
-  const sku = issue.sku ? ` (${issue.sku})` : "";
-  return `${issue.field}${sku}: ${issue.message}`;
-}
-async function assertGatewayPlansValidForPublish(client, projectId, plans) {
-  let result;
-  try {
-    result = await client.validateGatewayPlans(
-      projectId,
-      buildGatewayPlansValidationRequest(plans)
-    );
-  } catch (error) {
-    if (error instanceof PlatformApiError && (error.status === 404 || error.status === 405)) {
-      return { blocked: false };
-    }
-    throw error;
-  }
-  if (result.valid && result.errors.length === 0) {
-    return { blocked: false };
-  }
-  const errors = result.errors.map(toConfigIssue);
-  const warnings = result.warnings.map(toConfigIssue);
-  return {
-    blocked: true,
-    payload: {
-      status: "blocked",
-      reason: "gateway_plans_invalid",
-      projectId,
-      errors,
-      warnings,
-      userMessage: `Deploy is blocked: apitogo.config.json has ${errors.length} plan ${errors.length === 1 ? "error" : "errors"}.`,
-      nextStep: "Fix every issue listed in errors in apitogo.config.json plans, then retry publish."
-    }
-  };
-}
-
 // src/cli/platform/helpers/openapi-gateway-servers.ts
 import { mkdir as mkdir11, readFile as readFile15, writeFile as writeFile14 } from "node:fs/promises";
 import path55 from "node:path";
@@ -21055,6 +21061,25 @@ async function runApplyFromSiteDirectory(client, config2, args, progress) {
       emailOptions
     );
     await writeManifest(args.sourceDirectory, manifest);
+    if (includeApihub) {
+      await publishProgress?.onStep("Validating gateway plans");
+      const plansGate = await assertGatewayPlansValidForPublish(client, {
+        projectId: args.createNewProject ? void 0 : projectIdHint,
+        plans: manifest.plans ?? [],
+        planTier: args.platformPlan
+      });
+      if (plansGate.blocked) {
+        return JSON.stringify(
+          {
+            ...plansGate.payload,
+            completedSteps,
+            sourceDirectory: args.sourceDirectory
+          },
+          null,
+          2
+        );
+      }
+    }
     const stripeRequired = manifestRequiresStripe(manifest.plans);
     const ledgerResume = resolveResumeStepFromLedger(ledger, PUBLISH_STEPS);
     const effectiveResumeFromStep = args.resumeFromStep ?? ledgerResume;
@@ -21178,25 +21203,6 @@ async function runApplyFromSiteDirectory(client, config2, args, progress) {
         2
       );
     }
-    if (includeApihub) {
-      await publishProgress?.onStep("Validating gateway plans");
-      const plansGate = await assertGatewayPlansValidForPublish(
-        client,
-        projectId,
-        manifest.plans ?? []
-      );
-      if (plansGate.blocked) {
-        return JSON.stringify(
-          {
-            ...plansGate.payload,
-            completedSteps,
-            sourceDirectory: args.sourceDirectory
-          },
-          null,
-          2
-        );
-      }
-    }
     completedSteps.push({ step: "ensure_modules", status: "started" });
     let apihubReady = Promise.resolve();
     let devPortalReady = Promise.resolve();
@@ -22092,7 +22098,25 @@ async function askPlanChoice() {
     rl.close();
   }
 }
-async function resolvePlatformPlanInteractively(client, config2, payload) {
+async function askValidPlanChoice(validatePlansForTier) {
+  while (true) {
+    const choice = await askPlanChoice();
+    if (!choice || !validatePlansForTier) return choice;
+    printDiagnosticsToConsole(`Checking your API plans against ${choice}...`);
+    const errors = await validatePlansForTier(choice);
+    if (errors.length === 0) return choice;
+    printWarningToConsole(
+      `apitogo.config.json has ${errors.length} plan ${errors.length === 1 ? "error" : "errors"} for the ${choice} plan:`
+    );
+    for (const error of errors) {
+      printDiagnosticsToConsole(`  - ${error}`);
+    }
+    printDiagnosticsToConsole(
+      "Pick a different plan, or leave empty to cancel and fix apitogo.config.json."
+    );
+  }
+}
+async function resolvePlatformPlanInteractively(client, config2, payload, validatePlansForTier) {
   const projectId = typeof payload.projectId === "string" ? payload.projectId : "";
   if (!projectId) {
     return false;
@@ -22101,7 +22125,7 @@ async function resolvePlatformPlanInteractively(client, config2, payload) {
   if (typeof payload.platformPlanUserPrompt === "string") {
     printDiagnosticsToConsole(payload.platformPlanUserPrompt);
   }
-  const choice = await askPlanChoice();
+  const choice = await askValidPlanChoice(validatePlansForTier);
   if (!choice) {
     printWarningToConsole(
       "No plan selected. Re-run with --platform-plan free|starter|professional when you're ready."
@@ -22288,10 +22312,20 @@ async function apply(argv) {
     }
   }
   if (canPromptInteractively && parsed?.status === "blocked" && parsed.reason === "platform_plan_unselected") {
+    const blockedProjectId = typeof parsed.projectId === "string" ? parsed.projectId : void 0;
     const resolved = await resolvePlatformPlanInteractively(
       client,
       config2,
-      parsed
+      parsed,
+      async (planTier) => {
+        const manifest = await readManifest(sourceDirectory);
+        const check2 = await checkGatewayPlansOnPlatform(client, {
+          projectId: blockedProjectId,
+          plans: manifest?.plans ?? [],
+          planTier
+        });
+        return (check2?.errors ?? []).map(formatGatewayPlanIssue);
+      }
     );
     if (resolved) {
       try {

package/dist/declarations/cli/platform/client/platform-api.d.ts

@@ -403,7 +403,10 @@ export declare class PlatformApiClient {
     deployBackend(projectId: string, options: DeployBackendOptions): Promise<StartBackendDeploymentResponse>;
     listGatewayPlans(projectId: string): Promise<GatewayPlanDto[]>;
     createGatewayPlan(projectId: string, body: CreateGatewayPlanRequest): Promise<GatewayPlanDto>;
-    validateGatewayPlans(projectId: string, plans: ValidateGatewayPlanInput[]): Promise<GatewayPlansValidationResultDto>;
+    validateGatewayPlans(plans: ValidateGatewayPlanInput[], options?: {
+        projectId?: string;
+        planTier?: string;
+    }): Promise<GatewayPlansValidationResultDto>;
     getGatewayPlan(projectId: string, planId: string): Promise<GatewayPlanDto>;
     updateGatewayPlan(projectId: string, planId: string, body: UpdateGatewayPlanRequest): Promise<GatewayPlanDto>;
     deleteGatewayPlan(projectId: string, planId: string): Promise<void>;

package/dist/declarations/cli/platform/helpers/gateway-plan-validation.d.ts

@@ -2,7 +2,20 @@ import type { GatewayPlanValidationIssueDto, PlatformApiClient, ValidateGatewayP
 import { type ManifestPlanInput } from "./dev-portal-manifest.js";
 export declare function buildGatewayPlansValidationRequest(plans: ManifestPlanInput[]): ValidateGatewayPlanInput[];
 export declare function formatGatewayPlanIssue(issue: GatewayPlanValidationIssueDto): string;
-export declare function assertGatewayPlansValidForPublish(client: PlatformApiClient, projectId: string, plans: ManifestPlanInput[]): Promise<{
+export type GatewayPlansCheck = {
+    errors: GatewayPlanValidationIssueDto[];
+    warnings: GatewayPlanValidationIssueDto[];
+};
+export declare function checkGatewayPlansOnPlatform(client: PlatformApiClient, args: {
+    projectId?: string;
+    plans: ManifestPlanInput[];
+    planTier?: string;
+}): Promise<GatewayPlansCheck | null>;
+export declare function assertGatewayPlansValidForPublish(client: PlatformApiClient, args: {
+    projectId?: string;
+    plans: ManifestPlanInput[];
+    planTier?: string;
+}): Promise<{
     blocked: true;
     payload: Record<string, unknown>;
 } | {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lukoweb/apitogo",
-  "version": "0.1.134",
+  "version": "0.1.136",
   "type": "module",
   "sideEffects": [
     "**/*.css",