atmn 1.1.25 → 2.0.0

package/src/generated/wire.ts

@@ -0,0 +1,334 @@
+// Generated by @autumn/atmn-generator from packages/openapi/openapi-internal.yml.
+// Do not edit — run `bun generate` in packages/atmn-generator instead.
+
+import type { Feature } from "./features.js";
+import { LINT_RULES } from "./lintRules.js";
+import { ConfigError, lintDocument } from "./lintRuntime.js";
+import type { Plan } from "./plans.js";
+import type { ReferralProgram } from "./referralPrograms.js";
+import type { Reward } from "./rewards.js";
+import type { Settings } from "./settings.js";
+
+/** Operators like `$startsWith` are literal API keys, not snake_case fields. */
+const isOperatorKey = (key: string): boolean => key.startsWith("$");
+
+/** Only `_` before a LETTER folds — `_1` has no uppercase form to restore. */
+const toSnakeCase = (key: string): string =>
+	isOperatorKey(key)
+		? key
+		: key.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+
+const toCamelCase = (key: string): string =>
+	isOperatorKey(key)
+		? key
+		: key.replace(/_([a-z])/g, (_, c: string) => c.toUpperCase());
+
+export type PathHints = {
+	recordPaths: Set<string>;
+	frozenPaths: Set<string>;
+	/** Fixture path -> wire key, where the overlay renamed a field. */
+	renamedPaths: Map<string, string>;
+	/** Wire path -> fixture name: the same renames, read from a response. */
+	renamedWirePaths: Map<string, string>;
+};
+
+export type WireDocument = Record<string, unknown>;
+
+/** Stated relationship entries are complete desired state; no overlay means stock. */
+const clearOmittedRelationshipCustomizes = <T>(row: T): T => {
+	if (row === null || typeof row !== "object") return row;
+	const source = row as Record<string, unknown>;
+	const normalize = (entries: unknown): unknown =>
+		Array.isArray(entries)
+			? entries.map((entry) =>
+					entry !== null && typeof entry === "object"
+						? {
+								...(entry as Record<string, unknown>),
+								customize: (entry as Record<string, unknown>).customize ?? null,
+							}
+						: entry,
+				)
+			: entries;
+	return {
+		...source,
+		...(source.licenses !== undefined
+			? { licenses: normalize(source.licenses) }
+			: {}),
+		...(source.variants !== undefined
+			? { variants: normalize(source.variants) }
+			: {}),
+	} as T;
+};
+
+/**
+ * Fixture (camelCase) -> wire (snake_case), stopping where the spec says the
+ * data stops being ours. Array indices are elided from the path, so one hint
+ * covers every element.
+ */
+export const toWire = ({
+	value,
+	path,
+	hints,
+}: {
+	value: unknown;
+	path: string;
+	hints: PathHints;
+}): unknown => {
+	if (hints.frozenPaths.has(path)) return value;
+
+	if (Array.isArray(value)) {
+		return value.map((entry) => toWire({ value: entry, path, hints }));
+	}
+	if (value === null || typeof value !== "object") return value;
+
+	const source = value as Record<string, unknown>;
+
+	// A record's keys are the user's; its values are still ours.
+	if (hints.recordPaths.has(path)) {
+		return Object.fromEntries(
+			Object.entries(source).map(([key, entry]) => [
+				key,
+				toWire({ value: entry, path: `${path}.*`, hints }),
+			]),
+		);
+	}
+
+	return Object.fromEntries(
+		Object.entries(source).map(([key, entry]) => {
+			const childPath = path ? `${path}.${key}` : key;
+			return [
+				hints.renamedPaths.get(childPath) ?? toSnakeCase(key),
+				toWire({ value: entry, path: childPath, hints }),
+			];
+		}),
+	);
+};
+
+/**
+ * Wire (snake_case) -> fixture (camelCase), for responses. Hints are recorded
+ * in FIXTURE terms, so the path is built from the recased key.
+ */
+export const toFixture = ({
+	value,
+	path,
+	hints,
+}: {
+	value: unknown;
+	path: string;
+	hints: PathHints;
+}): unknown => {
+	if (hints.frozenPaths.has(path)) return value;
+
+	if (Array.isArray(value)) {
+		return value.map((entry) => toFixture({ value: entry, path, hints }));
+	}
+	if (value === null || typeof value !== "object") return value;
+
+	const source = value as Record<string, unknown>;
+
+	if (hints.recordPaths.has(path)) {
+		return Object.fromEntries(
+			Object.entries(source).map(([key, entry]) => [
+				key,
+				toFixture({ value: entry, path: `${path}.*`, hints }),
+			]),
+		);
+	}
+
+	return Object.fromEntries(
+		Object.entries(source).map(([key, entry]) => {
+			const name =
+				hints.renamedWirePaths.get(path ? `${path}.${key}` : key) ??
+				toCamelCase(key);
+			return [
+				name,
+				toFixture({
+					value: entry,
+					path: path ? `${path}.${name}` : name,
+					hints,
+				}),
+			];
+		}),
+	);
+};
+
+export const hintsOf = (hints: {
+	recordPaths: readonly string[];
+	frozenPaths: readonly string[];
+	renamedPaths: Readonly<Record<string, string>>;
+}): PathHints => ({
+	recordPaths: new Set(hints.recordPaths),
+	frozenPaths: new Set(hints.frozenPaths),
+	renamedPaths: new Map(Object.entries(hints.renamedPaths)),
+	renamedWirePaths: new Map(
+		Object.entries(hints.renamedPaths).map(([fixturePath, wireKey]) => {
+			const segments = fixturePath.split(".");
+			const parent = segments.slice(0, -1);
+			return [
+				[...parent, wireKey].join("."),
+				segments[segments.length - 1] ?? "",
+			];
+		}),
+	),
+});
+
+const CATALOG_HINTS = hintsOf({
+	recordPaths: [
+		"features.creditSchema.dimensions",
+		"features.creditSchema.dimensions.*.match",
+		"features.creditSchema.multipliers",
+		"features.creditSchema.multipliers.*.match",
+		"features.modelMarkups",
+		"features.providerMarkups",
+		"plans.billingControls.usageAlerts.filter.properties",
+		"plans.billingControls.usageLimits.filter.properties",
+		"plans.items.featureOverride.creditSchema.dimensions",
+		"plans.items.featureOverride.creditSchema.dimensions.*.match",
+		"plans.items.featureOverride.creditSchema.multipliers",
+		"plans.items.featureOverride.creditSchema.multipliers.*.match",
+		"plans.items.featureOverride.markups.modelMarkups",
+		"plans.items.featureOverride.markups.providerMarkups",
+		"plans.licenses.customize.addItems.featureOverride.creditSchema.dimensions",
+		"plans.licenses.customize.addItems.featureOverride.creditSchema.dimensions.*.match",
+		"plans.licenses.customize.addItems.featureOverride.creditSchema.multipliers",
+		"plans.licenses.customize.addItems.featureOverride.creditSchema.multipliers.*.match",
+		"plans.licenses.customize.addItems.featureOverride.markups.modelMarkups",
+		"plans.licenses.customize.addItems.featureOverride.markups.providerMarkups",
+		"plans.variants.customize.addItems.featureOverride.creditSchema.dimensions",
+		"plans.variants.customize.addItems.featureOverride.creditSchema.dimensions.*.match",
+		"plans.variants.customize.addItems.featureOverride.creditSchema.multipliers",
+		"plans.variants.customize.addItems.featureOverride.creditSchema.multipliers.*.match",
+		"plans.variants.customize.addItems.featureOverride.markups.modelMarkups",
+		"plans.variants.customize.addItems.featureOverride.markups.providerMarkups",
+		"plans.variants.customize.billingControls.usageAlerts.filter.properties",
+		"plans.variants.customize.billingControls.usageLimits.filter.properties",
+		"plans.variants.customize.items.featureOverride.creditSchema.dimensions",
+		"plans.variants.customize.items.featureOverride.creditSchema.dimensions.*.match",
+		"plans.variants.customize.items.featureOverride.creditSchema.multipliers",
+		"plans.variants.customize.items.featureOverride.creditSchema.multipliers.*.match",
+		"plans.variants.customize.items.featureOverride.markups.modelMarkups",
+		"plans.variants.customize.items.featureOverride.markups.providerMarkups",
+		"plans.variants.customize.upsertLicenses.customize.addItems.featureOverride.creditSchema.dimensions",
+		"plans.variants.customize.upsertLicenses.customize.addItems.featureOverride.creditSchema.dimensions.*.match",
+		"plans.variants.customize.upsertLicenses.customize.addItems.featureOverride.creditSchema.multipliers",
+		"plans.variants.customize.upsertLicenses.customize.addItems.featureOverride.creditSchema.multipliers.*.match",
+		"plans.variants.customize.upsertLicenses.customize.addItems.featureOverride.markups.modelMarkups",
+		"plans.variants.customize.upsertLicenses.customize.addItems.featureOverride.markups.providerMarkups",
+	],
+	frozenPaths: [
+		"plans.licenses.metadata",
+		"plans.metadata",
+		"plans.variants.customize.upsertLicenses.metadata",
+	],
+	renamedPaths: { "settings.paydownOverages": "persist_free_overage" },
+});
+
+export type AtmnConfig = {
+	/** Every features entry this catalog should have. `[]` means "mine, and
+	 * empty"; omitted means "not mine". */
+	features?: Feature[];
+	/** Every plans entry this catalog should have. `[]` means "mine, and
+	 * empty"; omitted means "not mine". */
+	plans?: Plan[];
+	/** Every rewards entry this catalog should have. `[]` means "mine, and
+	 * empty"; omitted means "not mine". */
+	rewards?: Reward[];
+	/** Every referralPrograms entry this catalog should have. `[]` means "mine, and
+	 * empty"; omitted means "not mine". */
+	referralPrograms?: ReferralProgram[];
+	/** The settings this config manages. Only the fields stated are written;
+	 * an omitted field keeps its value, and an omitted block manages nothing. */
+	settings?: Settings;
+};
+
+const stated = (config: AtmnConfig): Record<string, unknown> => ({
+	...(config.features !== undefined ? { features: config.features } : {}),
+	...(config.plans !== undefined
+		? {
+				plans: config.plans.map(clearOmittedRelationshipCustomizes),
+				// Stated plans are every version: the ones it omits are removed.
+				skip_version_deletions: false,
+			}
+		: {}),
+	...(config.rewards !== undefined ? { rewards: config.rewards } : {}),
+	...(config.referralPrograms !== undefined
+		? { referralPrograms: config.referralPrograms }
+		: {}),
+	...(config.settings !== undefined ? { settings: config.settings } : {}),
+});
+
+const SINGLETON_KEYS: readonly string[] = ["settings"];
+const CONFIG_KEYS: readonly string[] = [
+	"features",
+	"plans",
+	"rewards",
+	"referralPrograms",
+	"settings",
+];
+
+/**
+ * A key the type does not know is a config written for another version of
+ * this CLI, and the runtime loader does no type check: refused, never dropped.
+ */
+const unknownKeyIssue = (key: string): { path: string; message: string } =>
+	key === "planVersions"
+		? {
+				path: key,
+				message:
+					"planVersions is gone: every version is now a row in plans, with versionSlug and active. Rebuild the config from your org with `atmn pull --overwrite --yes` (commit first), or move the rows into plans.",
+			}
+		: {
+				path: key,
+				message: `${key} is not a config field. The fields are ${CONFIG_KEYS.join(", ")}.`,
+			};
+
+/**
+ * The catalog document and each singleton's own request body, split from the
+ * one document `atmn()` returns: they go to different operations.
+ */
+export const splitWire = (
+	document: WireDocument,
+): {
+	catalog: WireDocument;
+	singletons: Record<string, WireDocument | undefined>;
+} => ({
+	catalog: Object.fromEntries(
+		Object.entries(document).filter(([key]) => !SINGLETON_KEYS.includes(key)),
+	),
+	singletons: {
+		settings:
+			document.settings === undefined
+				? undefined
+				: { config: document.settings },
+	},
+});
+
+export const atmn = (config: AtmnConfig): WireDocument => {
+	const unknownKeys = Object.keys(config).filter(
+		(key) => !CONFIG_KEYS.includes(key),
+	);
+	if (unknownKeys.length > 0)
+		throw new ConfigError(unknownKeys.map(unknownKeyIssue));
+	const document = stated(config);
+	// Linted before anything is sent, and every problem is reported at once —
+	// a round trip per mistake is what makes a config painful to write.
+	const issues = lintDocument({
+		document,
+		rules: LINT_RULES,
+		hints: CATALOG_HINTS,
+	});
+	if (issues.length > 0) throw new ConfigError(issues);
+
+	return {
+		...(toWire({
+			value: document,
+			path: "",
+			hints: CATALOG_HINTS,
+		}) as WireDocument),
+		// The payload is the complete desired catalog, so omission is a removal.
+		skip_deletions: false,
+		// A constant, not a decision: "draft wherever one is warranted". The server
+		// works out which rows actually need one.
+		migration: { draft: true },
+	};
+};

package/src/http/autumnFetch.ts

@@ -0,0 +1,30 @@
+import { version } from "../version";
+
+const runtime =
+	typeof Bun !== "undefined"
+		? `bun ${Bun.version}`
+		: `node ${process.versions.node}`;
+
+/** What the server logs as `user_agent` for every request this CLI makes. */
+export const USER_AGENT = `atmn/${version} (${process.platform}; ${runtime})`;
+
+/** A fetch that stamps the CLI's user agent unless the caller already set one. */
+export const withUserAgent = (
+	base: typeof globalThis.fetch,
+): typeof globalThis.fetch => {
+	const stamped = (
+		input: Parameters<typeof globalThis.fetch>[0],
+		init?: Parameters<typeof globalThis.fetch>[1],
+	) => {
+		const headers = new Headers(init?.headers);
+		if (!headers.has("user-agent")) headers.set("user-agent", USER_AGENT);
+		return base(input, { ...init, headers });
+	};
+	// Bun's fetch carries extras like `preconnect`; keep them on the wrapper.
+	return Object.assign(stamped, base);
+};
+
+/** The one transport every request to Autumn goes through. */
+export const autumnFetch: typeof globalThis.fetch = withUserAgent(
+	globalThis.fetch,
+);

package/src/index.ts

@@ -0,0 +1,20 @@
+/**
+ * The package's import surface for a config: the builders and `atmn()`.
+ * Source-backed for workspace links; a built entry follows for npm.
+ */
+export { type Feature, feature } from "./generated/features.js";
+export { type License, license } from "./generated/licenses.js";
+export { type Plan, plan } from "./generated/plans.js";
+export {
+	type ReferralProgram,
+	referralProgram,
+} from "./generated/referralPrograms.js";
+export {
+	type Coupon,
+	coupon,
+	type FeatureGrant,
+	featureGrant,
+	type Reward,
+} from "./generated/rewards.js";
+export { type Variant, variant } from "./generated/variants.js";
+export { type AtmnConfig, atmn } from "./generated/wire.js";

package/src/project/chooseConfigDir.ts

@@ -0,0 +1,41 @@
+import { relative, resolve } from "node:path";
+import { COLLECTION_FILES } from "../actions/pull/scaffoldConfig";
+import { configPackageName } from "../config/configPackageName";
+import { ask, done, type Prompter, soft } from "../prompt/prompt";
+import { findRepoLayout } from "../repo/findRepoRoot";
+
+/** The config folder when nothing states it: its own package in a workspace, else `autumn/`. */
+export const defaultConfigDirName = ({ cwd }: { cwd: string }): string =>
+	findRepoLayout({ cwd }).hasWorkspaces ? "packages/autumn/" : "autumn/";
+
+const configFiles = ["autumn.config.ts", ...Object.keys(COLLECTION_FILES)];
+
+/**
+ * No flag, no config beside cwd, no root marker: say what is about to be
+ * created and ask where, before writing anything. Headless prints the `-c`
+ * hint and stops, so nothing lands in a folder the user never chose.
+ */
+export const chooseConfigDir = async ({
+	cwd,
+	prompter,
+}: {
+	cwd: string;
+	prompter: Prompter;
+}): Promise<{ configDir: string; repoRoot: string }> => {
+	const { repoRoot } = findRepoLayout({ cwd });
+	const fallback = defaultConfigDirName({ cwd });
+	prompter.write(
+		`${soft("No autumn.config.ts found.")}\n  atmn keeps your pricing in one folder: ${configFiles.join(", ")}.\n`,
+	);
+	const chosen = await ask({
+		prompter,
+		value: undefined,
+		question: "Where should that folder live?",
+		flag: `-c <dir> (or run ${configPackageName()} init)`,
+		example: `-c ${fallback}`,
+		defaultValue: fallback,
+	});
+	const configDir = resolve(repoRoot, chosen);
+	prompter.write(`${done(`Path ${relative(repoRoot, configDir) || "."}`)}\n`);
+	return { configDir, repoRoot };
+};

package/src/project/resolveProject.ts

@@ -0,0 +1,115 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { findRepoLayout } from "../repo/findRepoRoot";
+
+const CONFIG_FILENAMES = ["autumn.config.ts", "autumn.config.js"] as const;
+
+/** The root package.json field `atmn init` writes so later commands find the config from anywhere in the repo. */
+export const MARKER_FIELD = "atmn";
+
+export type ProjectMarker = { config: string };
+
+export type Project = {
+	repoRoot: string;
+	/** The config file, when one could be found. */
+	configPath: string | null;
+	/** Where fixtures and skills/ live: the config's folder, else cwd. */
+	configDir: string;
+	/** Where `.env` is looked for, root first: an existing file anywhere here is
+	 * reused, and a new one is created at the root so one file serves every package. */
+	envDirs: string[];
+	/** How the config was found; `hint` is printed when a command needs one and there is none. */
+	source: "flag" | "cwd" | "marker" | "none";
+};
+
+const configIn = ({ dir }: { dir: string }): string | null => {
+	for (const filename of CONFIG_FILENAMES) {
+		const path = join(dir, filename);
+		if (existsSync(path)) return path;
+	}
+	return null;
+};
+
+/** `-c` takes a file or a directory; a directory means the config it holds, or a new autumn.config.ts. */
+export const configPathFromFlag = ({
+	cwd,
+	flag,
+}: {
+	cwd: string;
+	flag: string;
+}): string => {
+	const resolved = isAbsolute(flag) ? flag : resolve(cwd, flag);
+	const isFile = /\.(ts|js)$/.test(resolved);
+	if (isFile) return resolved;
+	if (existsSync(resolved) && !statSync(resolved).isDirectory())
+		return resolved;
+	// A folder means whichever config it holds; a new folder gets the .ts one.
+	return configIn({ dir: resolved }) ?? join(resolved, "autumn.config.ts");
+};
+
+export const readMarker = ({
+	repoRoot,
+}: {
+	repoRoot: string;
+}): ProjectMarker | null => {
+	const manifest = join(repoRoot, "package.json");
+	if (!existsSync(manifest)) return null;
+	try {
+		const parsed = JSON.parse(readFileSync(manifest, "utf8")) as Record<
+			string,
+			unknown
+		>;
+		const marker = parsed[MARKER_FIELD];
+		if (
+			typeof marker === "object" &&
+			marker !== null &&
+			typeof (marker as ProjectMarker).config === "string"
+		)
+			return { config: (marker as ProjectMarker).config };
+		return null;
+	} catch {
+		return null;
+	}
+};
+
+/**
+ * Where this run's config and `.env` are. The flag wins, then a config beside
+ * cwd, then the root marker `atmn init` wrote: the common case of running
+ * `atmn push` from the repo root of a monorepo lands on the marker.
+ */
+export const resolveProject = ({
+	cwd,
+	configFlag,
+}: {
+	cwd: string;
+	configFlag?: string;
+}): Project => {
+	const { repoRoot, packageRoot } = findRepoLayout({ cwd });
+
+	let configPath: string | null = null;
+	let source: Project["source"] = "none";
+	if (configFlag !== undefined) {
+		configPath = configPathFromFlag({ cwd, flag: configFlag });
+		source = "flag";
+	} else if (configIn({ dir: cwd }) !== null) {
+		configPath = configIn({ dir: cwd });
+		source = "cwd";
+	} else {
+		const marker = readMarker({ repoRoot });
+		if (marker !== null) {
+			configPath = resolve(repoRoot, marker.config);
+			source = "marker";
+		}
+	}
+
+	const configDir = configPath === null ? cwd : dirname(configPath);
+	return {
+		repoRoot,
+		configPath,
+		configDir,
+		envDirs: [
+			...new Set([repoRoot, configDir, cwd, join(cwd, "atmn"), packageRoot]),
+		],
+		source,
+	};
+};

package/src/project/rootMarker.ts

@@ -0,0 +1,40 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { configPackageName } from "../config/configPackageName";
+import { MARKER_FIELD, readMarker } from "./resolveProject";
+
+const readJson = (path: string): Record<string, unknown> =>
+	JSON.parse(readFileSync(path, "utf8")) as Record<string, unknown>;
+
+const writeJson = (path: string, value: unknown): void => {
+	writeFileSync(path, `${JSON.stringify(value, null, "\t")}\n`, "utf8");
+};
+
+/** The root's marker and script, added beside whatever is already there. */
+export const writeRootMarker = ({
+	repoRoot,
+	configPath,
+}: {
+	repoRoot: string;
+	configPath: string;
+}): boolean => {
+	const manifestPath = join(repoRoot, "package.json");
+	const manifest = existsSync(manifestPath) ? readJson(manifestPath) : {};
+	const config = relative(repoRoot, configPath);
+	const scripts = (manifest.scripts ?? {}) as Record<string, string>;
+	const next = {
+		...manifest,
+		scripts: {
+			...scripts,
+			atmn: `${configPackageName()} -c ${JSON.stringify(config)}`,
+		},
+		[MARKER_FIELD]: { config },
+	};
+	if (
+		readMarker({ repoRoot })?.config === config &&
+		scripts.atmn === next.scripts.atmn
+	)
+		return false;
+	writeJson(manifestPath, next);
+	return true;
+};