@lukoweb/apitogo 0.1.133 → 0.1.135

package/dist/cli/cli.js

@@ -5809,7 +5809,7 @@ import {
 // package.json
 var package_default = {
   name: "@lukoweb/apitogo",
-  version: "0.1.133",
+  version: "0.1.135",
   type: "module",
   sideEffects: [
     "**/*.css",
@@ -11252,6 +11252,17 @@ var PlatformApiClient = class {
       }
     );
   }
+  /**
+   * 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(
       "GET",
@@ -16805,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) {
@@ -20983,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;
@@ -21899,6 +21996,26 @@ function formatBlockedOrFailedResultForHuman(parsed) {
     );
     return lines;
   }
+  if (status2 === "blocked" && parsed.reason === "gateway_plans_invalid") {
+    const lines = [
+      typeof parsed.userMessage === "string" ? parsed.userMessage : "Deploy is blocked: apitogo.config.json has plan errors."
+    ];
+    for (const issue of Array.isArray(parsed.errors) ? parsed.errors : []) {
+      lines.push(`  - ${formatGatewayPlanIssue(issue)}`);
+    }
+    const warnings = Array.isArray(parsed.warnings) ? parsed.warnings : [];
+    if (warnings.length > 0) {
+      lines.push("", "Warnings:");
+      for (const issue of warnings) {
+        lines.push(`  - ${formatGatewayPlanIssue(issue)}`);
+      }
+    }
+    lines.push(
+      "",
+      "Fix these in apitogo.config.json, then re-run `apitogo deploy`."
+    );
+    return lines;
+  }
   if (status2 === "blocked") {
     return [
       typeof parsed.userMessage === "string" ? parsed.userMessage : `Deploy is blocked${typeof parsed.reason === "string" ? `: ${parsed.reason}` : "."}`
@@ -21981,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;
@@ -21990,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."
@@ -22177,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

@@ -343,6 +343,20 @@ export interface BackendDeploymentDetailDto {
     runtimeVersion: string;
     backendUrl?: string | null;
 }
+export interface GatewayPlanValidationIssueDto {
+    field: string;
+    message: string;
+    planIndex?: number | null;
+    sku?: string | null;
+}
+export interface GatewayPlansValidationResultDto {
+    valid: boolean;
+    errors: GatewayPlanValidationIssueDto[];
+    warnings: GatewayPlanValidationIssueDto[];
+}
+export type ValidateGatewayPlanInput = Omit<CreateGatewayPlanRequest, "includedActionKeys"> & {
+    includedActionKeys?: string[];
+};
 export declare class PlatformApiClient {
     private readonly config;
     constructor(config: ApitogoConfig);
@@ -389,6 +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(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

@@ -0,0 +1,23 @@
+import type { GatewayPlanValidationIssueDto, PlatformApiClient, ValidateGatewayPlanInput } from "../client/platform-api.js";
+import { type ManifestPlanInput } from "./dev-portal-manifest.js";
+export declare function buildGatewayPlansValidationRequest(plans: ManifestPlanInput[]): ValidateGatewayPlanInput[];
+export declare function formatGatewayPlanIssue(issue: GatewayPlanValidationIssueDto): string;
+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>;
+} | {
+    blocked: false;
+}>;

package/package.json

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