@lukoweb/apitogo 0.2.47 → 0.2.49

package/src/config/v2/rules.ts

@@ -2,6 +2,7 @@ import { readdir, readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { glob } from "glob";
 import { parse as parseYaml } from "yaml";
+import { billingNeeded, stripeKeySecretName } from "./billing.js";
 import type { ConfigIssue } from "./errors.js";
 import { type ResolvedConfigV2, toGlobPath } from "./resolve.js";
 import type { ConfigV2 } from "./schema.js";
@@ -657,9 +658,9 @@ function identityRules(
 // --- plans (2.6) ----------------------------------------------------------------------------------------------------
 
 async function plansRules(
-  config: ConfigV2,
   resolved: ResolvedConfigV2,
   out: Collector,
+  paid: boolean,
 ) {
   const plans = resolved.plans;
   if (!plans?.enabled) return;
@@ -683,16 +684,8 @@ async function plansRules(
     }
   }
 
-  if (plans.billing.provider === "stripe") {
-    if (!config.plans?.billing?.apiKey) {
-      out.error({
-        code: "PLANS_BILLING_INCOMPLETE",
-        path: "plans.billing.apiKey",
-        message:
-          "plans.billing.apiKey is required when billing.provider is stripe.",
-        hint: 'Set it to a secret reference, for example "secret:STRIPE_API_KEY".',
-      });
-    }
+  // Billing is on only when a plan has a price. The Stripe key defaults to the STRIPE_API_KEY secret.
+  if (paid) {
     const headless = !(resolved.portal?.enabled === true);
     for (const field of ["successUrl", "cancelUrl"] as const) {
       if (headless && !plans.billing[field]) {
@@ -711,11 +704,22 @@ async function plansRules(
 
 function secretRules(
   config: ConfigV2,
+  resolved: ResolvedConfigV2,
   context: CheckContext,
   out: Collector,
   skipped: string[],
+  paid: boolean,
 ) {
-  const refs = collectSecretRefs(config);
+  // The billing secrets matter only when a plan has a price. The Stripe key is then needed even when the config does not
+  // name it (it defaults to STRIPE_API_KEY). `apitogo deploy` asks for it, so a missing key is a warning, not an error.
+  const stripeKeyPath = "plans.billing.apiKey";
+  const named = collectSecretRefs(config).filter(
+    (ref) => paid || !ref.path.startsWith("plans.billing"),
+  );
+  const refs =
+    paid && !named.some((ref) => ref.path === stripeKeyPath)
+      ? [...named, { name: stripeKeySecretName(resolved), path: stripeKeyPath }]
+      : named;
   if (refs.length === 0) return;
   if (!context.knownSecrets) {
     skipped.push(
@@ -724,7 +728,14 @@ function secretRules(
     return;
   }
   for (const ref of refs) {
-    if (!context.knownSecrets.has(ref.name)) {
+    if (ref.path === stripeKeyPath && !context.knownSecrets.has(ref.name)) {
+      out.warn({
+        code: "SECRET_NOT_SET",
+        path: ref.path,
+        message: `a plan has a price, and the Stripe key (secret ${ref.name}) is not set yet.`,
+        hint: `apitogo deploy asks for it. Or run: apitogo secrets set ${ref.name}`,
+      });
+    } else if (!context.knownSecrets.has(ref.name)) {
       out.error({
         code: "SECRET_NOT_SET",
         path: ref.path,
@@ -751,12 +762,13 @@ export async function checkConfigV2(
     warn: (issue) => warnings.push(issue),
   };
 
+  const paid = await billingNeeded(resolved);
   dependencyRules(config, resolved, out);
-  secretRules(config, context, out, skipped);
+  secretRules(config, resolved, context, out, skipped, paid);
   await portalRules(config, resolved, out);
   await gatewayRules(resolved, out);
   identityRules(config, resolved, out);
-  await plansRules(config, resolved, out);
+  await plansRules(resolved, out, paid);
 
   return { errors, warnings, skipped };
 }

package/src/config/v2/services.ts

@@ -9,6 +9,7 @@ import {
 } from "node:fs/promises";
 import path from "node:path";
 import { ApitogoError } from "../../lib/util/invariant.js";
+import { isPaidPlan } from "./billing.js";
 import {
   FULL_SERVER_HEALTH_PATH,
   FULL_SERVER_TIMEOUT_SECONDS,
@@ -182,7 +183,6 @@ export type AddOptions = {
   plans?: {
     file?: string;
     template?: "free" | "tiered" | "none";
-    billing?: "stripe" | "none";
   };
 };
 
@@ -773,15 +773,8 @@ async function buildPlans(
       : isFilled(options.template)
         ? "starter"
         : "free");
-  // Only paid plans need a billing provider. A catalog of free plans takes no payment, so its default is `none` and the
-  // config checks clean right away; the tiered template (paid plans) defaults to Stripe, whose key is set with `secrets set`.
-  const billing = o.billing ?? (template === "tiered" ? "stripe" : "none");
-  if (template === "tiered" && billing === "none") {
-    throw new ServiceEditError(
-      "The tiered template has paid plans, which need a billing provider.",
-      "Use --billing stripe, or --template free.",
-    );
-  }
+  // Stripe is the only billing provider, and it is needed only once a plan has a price: the config names no billing
+  // settings, and `apitogo deploy` asks for the Stripe key (secret STRIPE_API_KEY) the first time a paid plan is deployed.
   const file = o.file ? insideProject(dir, o.file, "Plans file") : undefined;
   const target = file
     ? path.join(dir, file)
@@ -791,22 +784,14 @@ async function buildPlans(
     target,
     `${JSON.stringify({ version: 1, plans: PLAN_TEMPLATES[template] }, null, 2)}\n`,
   );
-  if (billing === "stripe") {
+  if (PLAN_TEMPLATES[template].some((plan) => isPaidPlan(plan))) {
     context.notes.push(
-      "Set the billing key: apitogo secrets set STRIPE_API_KEY",
+      "A plan has a price, so payments go through Stripe: apitogo deploy asks for your Stripe secret key.",
     );
   }
   return {
     ...(options.disabled ? { enabled: false } : {}),
     ...(file ? { file } : {}),
-    ...(billing === "stripe"
-      ? {
-          billing: {
-            provider: "stripe" as const,
-            apiKey: "secret:STRIPE_API_KEY",
-          },
-        }
-      : { billing: { provider: "none" as const } }),
   };
 }