atmn 1.0.0-beta.2 → 1.0.0-beta.3

package/dist/{chunk-UM3AMTOI.js → chunk-HILICWQ7.js}

@@ -1,4 +1,4 @@
-import { isLocalFlag, readFromEnv } from './chunk-PKRTTZCX.js';
+import { isLocalFlag, readFromEnv } from './chunk-W6GJPEQT.js';
 import chalk from 'chalk';
 import axios, { AxiosError } from 'axios';
 
@@ -28,7 +28,7 @@ export const pro = plan({
 	name: 'Pro',
 	description: 'Professional plan for growing teams',
 	add_on: false,
-	default: false,
+	auto_enable: false,
 	price: {
 		amount: 50,
 		interval: 'month',
@@ -48,16 +48,13 @@ export const pro = plan({
 			price: {
 				amount: 10,
 				interval: 'month',
-				usage_model: 'pay_per_use',
+				billing_method: 'pay_per_use',
 				billing_units: 1,
 			},
 		}),
 	],
 });
 `;
-
-// source/core/api.ts
-var INTERNAL_BASE = BACKEND_URL;
 var EXTERNAL_BASE = `${BACKEND_URL}/v1`;
 async function request({
   method,
@@ -72,7 +69,6 @@ async function request({
   bypass
 }) {
   if (isLocalFlag()) {
-    INTERNAL_BASE = "http://localhost:8080";
     EXTERNAL_BASE = "http://localhost:8080/v1";
     if (base) {
       base = base.replace(BACKEND_URL, "http://localhost:8080");
@@ -118,23 +114,6 @@ ${chalk.bgRed.white.bold("  API REQUEST FAILED  ")}`);
     process.exit(1);
   }
 }
-async function internalRequest({
-  method,
-  path,
-  data,
-  headers,
-  customAuth
-}) {
-  return await request({
-    method,
-    base: INTERNAL_BASE,
-    path,
-    data,
-    headers,
-    customAuth,
-    bypass: true
-  });
-}
 async function externalRequest({
   method,
   path,
@@ -171,18 +150,6 @@ async function deletePlan({
     queryParams: { all_versions: !!allVersions }
   });
 }
-async function updateCLIStripeKeys({
-  stripeSecretKey,
-  autumnSecretKey
-}) {
-  return await request({
-    base: EXTERNAL_BASE,
-    method: "POST",
-    path: "/organization/stripe",
-    data: { secret_key: stripeSecretKey },
-    secretKey: autumnSecretKey
-  });
-}
 
 // source/core/pull.ts
 async function getPlans(ids) {
@@ -236,7 +203,7 @@ async function getFeatures(params) {
     path: "/features",
     queryParams: { include_archived: params?.includeArchived ? true : false }
   });
-  return list.map((feature) => feature);
+  return list;
 }
 var MAX_RECURSION_LIMIT = 500;
 async function getCustomers(limit = 100, offset = 0) {
@@ -264,4 +231,4 @@ async function getCustomers(limit = 100, offset = 0) {
   return customers;
 }
 
-export { DEFAULT_CONFIG, FRONTEND_URL, deleteFeature, deletePlan, externalRequest, getAllPlanVariants, getAllPlans, getCustomers, getFeatures, getPlans, internalRequest, updateCLIStripeKeys };
+export { BACKEND_URL, DEFAULT_CONFIG, FRONTEND_URL, deleteFeature, deletePlan, externalRequest, getAllPlanVariants, getAllPlans, getCustomers, getFeatures, getPlans };

package/dist/{chunk-PKRTTZCX.js → chunk-NBLVYKWE.js}

@@ -4,16 +4,28 @@ import dotenv from 'dotenv';
 import fs from 'fs';
 import yoctoSpinner from 'yocto-spinner';
 
+// source/core/utils.ts
+
+// source/core/cliContext.ts
+var context = {
+  prod: false,
+  local: false
+};
+function isProd() {
+  return context.prod;
+}
+function isLocal() {
+  return context.local;
+}
+
 // source/core/utils.ts
 var notNullish = (value) => value !== null && value !== void 0;
 var nullish = (value) => value === null || value === void 0;
 var isProdFlag = () => {
-  const prodFlag = process.argv.includes("--prod") || process.argv.includes("-p");
-  return prodFlag;
+  return isProd();
 };
 var isLocalFlag = () => {
-  const localFlag = process.argv.includes("--local") || process.argv.includes("-l");
-  return localFlag;
+  return isLocal();
 };
 function snakeCaseToCamelCase(value) {
   return value.replace(/_([a-z])/g, (_match, letter) => letter.toUpperCase());
@@ -34,21 +46,22 @@ function idToVar({
 async function upsertEnvVar(filePath, varName, newValue) {
   const content = fs.readFileSync(filePath, "utf-8");
   const lines = content.split("\n");
-  let found = false;
+  let foundIndex = -1;
   for (let i = 0; i < lines.length; i++) {
     if (lines[i]?.startsWith(`${varName}=`)) {
-      const shouldOverwrite = await confirm({
-        message: `${varName} already exists in .env. Overwrite?`,
-        default: false
-      });
-      if (shouldOverwrite) {
-        lines[i] = `${varName}=${newValue}`;
-        found = true;
-        break;
-      }
+      foundIndex = i;
+      break;
     }
   }
-  if (!found) {
+  if (foundIndex !== -1) {
+    const shouldOverwrite = await confirm({
+      message: `${varName} already exists in .env. Overwrite?`,
+      default: false
+    });
+    if (shouldOverwrite) {
+      lines[foundIndex] = `${varName}=${newValue}`;
+    }
+  } else {
     lines.push(`${varName}=${newValue}`);
   }
   fs.writeFileSync(filePath, lines.join("\n"));

package/dist/chunk-TBJ5X4CL.js

@@ -0,0 +1,234 @@
+import { isLocalFlag, readFromEnv } from './chunk-NBLVYKWE.js';
+import chalk from 'chalk';
+import axios, { AxiosError } from 'axios';
+
+// source/constants.ts
+var FRONTEND_URL = "http://localhost:3000";
+var BACKEND_URL = "http://localhost:8080";
+var DEFAULT_CONFIG = `import {
+	feature,
+	plan,
+	planFeature,
+} from 'atmn';
+
+export const seats = feature({
+	id: 'seats',
+	name: 'Seats',
+	type: 'continuous_use',
+});
+
+export const messages = feature({
+	id: 'messages',
+	name: 'Messages',
+	type: 'single_use',
+});
+
+export const pro = plan({
+	id: 'pro',
+	name: 'Pro',
+	description: 'Professional plan for growing teams',
+	add_on: false,
+	auto_enable: false,
+	price: {
+		amount: 50,
+		interval: 'month',
+	},
+	features: [
+		// 500 messages per month
+		planFeature({
+			feature_id: messages.id,
+			granted: 500,
+			reset: { interval: 'month' },
+		}),
+
+		// $10 per seat per month
+		planFeature({
+			feature_id: seats.id,
+			granted: 1,
+			price: {
+				amount: 10,
+				interval: 'month',
+				billing_method: 'pay_per_use',
+				billing_units: 1,
+			},
+		}),
+	],
+});
+`;
+var EXTERNAL_BASE = `${BACKEND_URL}/v1`;
+async function request({
+  method,
+  base,
+  path,
+  data,
+  headers,
+  customAuth,
+  throwOnError = true,
+  secretKey,
+  queryParams,
+  bypass
+}) {
+  if (isLocalFlag()) {
+    EXTERNAL_BASE = "http://localhost:8080/v1";
+    if (base) {
+      base = base.replace(BACKEND_URL, "http://localhost:8080");
+    }
+  }
+  const apiKey = secretKey || readFromEnv({ bypass });
+  try {
+    const response = await axios.request({
+      method,
+      url: `${base}${path}`,
+      data,
+      params: queryParams,
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Version": "2.0.0",
+        ...headers,
+        Authorization: customAuth || `Bearer ${apiKey}`
+      }
+    });
+    return response.data;
+  } catch (error) {
+    if (throwOnError) {
+      throw error;
+    }
+    console.error(`
+${chalk.bgRed.white.bold("  API REQUEST FAILED  ")}`);
+    const methodPath = `${method.toUpperCase()} ${base}${path}`;
+    console.error(chalk.red(methodPath));
+    if (error instanceof AxiosError) {
+      const status = error.response?.status;
+      const data2 = error.response?.data;
+      const code = data2?.code || data2?.error || "unknown_error";
+      const message = data2?.message || error.message || "An unknown error occurred";
+      if (status) {
+        console.error(chalk.redBright(`[${status}] ${code}`));
+      }
+      console.error(chalk.red(message));
+    } else if (error instanceof Error) {
+      console.error(chalk.red(error.message));
+    } else {
+      console.error(chalk.red(String(error)));
+    }
+    process.exit(1);
+  }
+}
+async function externalRequest({
+  method,
+  path,
+  data,
+  headers,
+  customAuth,
+  throwOnError = false,
+  queryParams
+}) {
+  return await request({
+    method,
+    base: EXTERNAL_BASE,
+    path,
+    data,
+    headers,
+    customAuth,
+    throwOnError,
+    queryParams
+  });
+}
+async function deleteFeature({ id }) {
+  return await externalRequest({
+    method: "DELETE",
+    path: `/features/${id}`
+  });
+}
+async function deletePlan({
+  id,
+  allVersions
+}) {
+  return await externalRequest({
+    method: "DELETE",
+    path: `/products/${id}`,
+    queryParams: { all_versions: !!allVersions }
+  });
+}
+
+// source/core/pull.ts
+async function getPlans(ids) {
+  return await Promise.all(
+    ids.map(
+      (id) => externalRequest({
+        method: "GET",
+        path: `/products/${id}`
+      })
+    )
+  );
+}
+async function getAllPlans(params) {
+  const { list: plans } = await externalRequest({
+    method: "GET",
+    path: `/products`,
+    queryParams: { include_archived: params?.archived ? true : false }
+  });
+  return [...plans];
+}
+async function getAllPlanVariants() {
+  const { list } = await externalRequest({
+    method: "GET",
+    path: "/products"
+  });
+  const allPlans = [];
+  allPlans.push(
+    ...list.flatMap((plan) => {
+      if (plan.version > 1) {
+        return Array.from({ length: plan.version }, (_, i) => ({
+          id: plan.id,
+          name: plan.name,
+          version: i + 1
+        }));
+      } else {
+        return [
+          {
+            id: plan.id,
+            name: plan.name,
+            version: plan.version
+          }
+        ];
+      }
+    })
+  );
+  return allPlans;
+}
+async function getFeatures(params) {
+  const { list } = await externalRequest({
+    method: "GET",
+    path: "/features",
+    queryParams: { include_archived: params?.includeArchived ? true : false }
+  });
+  return list;
+}
+var MAX_RECURSION_LIMIT = 500;
+async function getCustomers(limit = 100, offset = 0) {
+  const { list, total } = await externalRequest({
+    method: "GET",
+    path: `/customers?limit=${limit}&offset=${offset}`
+  });
+  const customers = list.map(
+    (customer) => ({
+      id: customer.id,
+      text: customer.name || customer.email || customer.id
+    })
+  );
+  if (offset + limit < total && offset < MAX_RECURSION_LIMIT) {
+    const remainingCustomers = await getCustomers(limit, offset + limit);
+    return [...customers, ...remainingCustomers];
+  } else if (offset >= MAX_RECURSION_LIMIT) {
+    console.log(
+      chalk.red(
+        `Reached maximum recursion limit of ${MAX_RECURSION_LIMIT} customers. Exiting.`
+      )
+    );
+    process.exit(1);
+  }
+  return customers;
+}
+
+export { BACKEND_URL, DEFAULT_CONFIG, FRONTEND_URL, deleteFeature, deletePlan, externalRequest, getAllPlanVariants, getAllPlans, getCustomers, getFeatures, getPlans };

package/dist/chunk-W6GJPEQT.js

@@ -0,0 +1,136 @@
+import { confirm } from '@inquirer/prompts';
+import chalk from 'chalk';
+import dotenv from 'dotenv';
+import fs from 'fs';
+import yoctoSpinner from 'yocto-spinner';
+
+// source/core/utils.ts
+
+// source/core/cliContext.ts
+var context = {
+  prod: false,
+  local: false
+};
+function isProd() {
+  return context.prod;
+}
+function isLocal() {
+  return context.local;
+}
+
+// source/core/utils.ts
+var notNullish = (value) => value !== null && value !== void 0;
+var nullish = (value) => value === null || value === void 0;
+var isProdFlag = () => {
+  return isProd();
+};
+var isLocalFlag = () => {
+  return isLocal();
+};
+function snakeCaseToCamelCase(value) {
+  return value.replace(/_([a-z])/g, (_match, letter) => letter.toUpperCase());
+}
+function idToVar({
+  id,
+  prefix = "product"
+}) {
+  const processed = id.replace(/[-_](.)/g, (_, letter) => letter.toUpperCase()).replace(/[^a-zA-Z0-9_$]/g, "");
+  if (/^[0-9]/.test(processed)) {
+    return `${prefix}${processed}`;
+  }
+  if (/^[^a-zA-Z_$]/.test(processed)) {
+    return `${prefix}${processed}`;
+  }
+  return processed;
+}
+async function upsertEnvVar(filePath, varName, newValue) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  const lines = content.split("\n");
+  let foundIndex = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i]?.startsWith(`${varName}=`)) {
+      foundIndex = i;
+      break;
+    }
+  }
+  if (foundIndex !== -1) {
+    const shouldOverwrite = await confirm({
+      message: `${varName} already exists in .env. Overwrite?`,
+      default: false
+    });
+    if (shouldOverwrite) {
+      lines[foundIndex] = `${varName}=${newValue}`;
+    }
+  } else {
+    lines.push(`${varName}=${newValue}`);
+  }
+  fs.writeFileSync(filePath, lines.join("\n"));
+}
+async function storeToEnv(prodKey, sandboxKey) {
+  const envPath = `${process.cwd()}/.env`;
+  const envLocalPath = `${process.cwd()}/.env.local`;
+  const envVars = `AUTUMN_PROD_SECRET_KEY=${prodKey}
+AUTUMN_SECRET_KEY=${sandboxKey}
+`;
+  if (fs.existsSync(envPath)) {
+    await upsertEnvVar(envPath, "AUTUMN_PROD_SECRET_KEY", prodKey);
+    await upsertEnvVar(envPath, "AUTUMN_SECRET_KEY", sandboxKey);
+    console.log(chalk.green(".env file found. Updated keys."));
+  } else if (fs.existsSync(envLocalPath)) {
+    fs.writeFileSync(envPath, envVars);
+    console.log(
+      chalk.green(
+        ".env.local found but .env not found. Created new .env file and wrote keys."
+      )
+    );
+  } else {
+    fs.writeFileSync(envPath, envVars);
+    console.log(
+      chalk.green(
+        "No .env or .env.local file found. Created new .env file and wrote keys."
+      )
+    );
+  }
+}
+function getEnvVar(parsed, prodFlag) {
+  return parsed["AUTUMN_SECRET_KEY"];
+}
+function readFromEnv(options) {
+  const envPath = `${process.cwd()}/.env`;
+  const envLocalPath = `${process.cwd()}/.env.local`;
+  if (process.env["AUTUMN_SECRET_KEY"]) {
+    return process.env["AUTUMN_SECRET_KEY"];
+  }
+  let secretKey;
+  if (fs.existsSync(envPath) && !secretKey)
+    secretKey = getEnvVar(
+      dotenv.parse(fs.readFileSync(envPath, "utf-8")));
+  if (fs.existsSync(envLocalPath) && !secretKey)
+    secretKey = getEnvVar(
+      dotenv.parse(fs.readFileSync(envLocalPath, "utf-8")));
+  if (!secretKey && !options?.bypass) {
+    {
+      console.error(
+        "[Error] atmn uses the AUTUMN_SECRET_KEY to call the Autumn sandbox API. Please add it to your .env (or .env.local) file or run `atmn login` to authenticate."
+      );
+      process.exit(1);
+    }
+  }
+  return secretKey;
+}
+function initSpinner(message) {
+  const spinner = yoctoSpinner({
+    text: message
+  });
+  spinner.start();
+  return spinner;
+}
+async function isSandboxKey(apiKey) {
+  const prefix = apiKey.split("am_sk_")[1]?.split("_")[0];
+  if (prefix === "live") {
+    return false;
+  } else if (prefix === "test") return true;
+  else throw new Error("Invalid API key");
+}
+
+export { idToVar, initSpinner, isLocalFlag, isProdFlag, isSandboxKey, notNullish, nullish, readFromEnv, snakeCaseToCamelCase, storeToEnv };