atmn 0.0.4 → 0.0.6

package/dist/cli.cjs

@@ -0,0 +1,603 @@
+#!/usr/bin/env node
+'use strict';
+
+var commander = require('commander');
+var chalk6 = require('chalk');
+var axios = require('axios');
+var fs = require('fs');
+var path = require('path');
+var createJiti = require('jiti');
+var url = require('url');
+var open = require('open');
+var prompts = require('@inquirer/prompts');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var chalk6__default = /*#__PURE__*/_interopDefault(chalk6);
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var createJiti__default = /*#__PURE__*/_interopDefault(createJiti);
+var open__default = /*#__PURE__*/_interopDefault(open);
+
+// ../node_modules/.pnpm/tsup@8.5.0_jiti@2.4.2_postcss@8.5.6_tsx@4.20.3_typescript@5.8.3_yaml@2.8.0/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.src || new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// source/constants.ts
+var FRONTEND_URL = "http://app.useautumn.com";
+var BACKEND_URL = "https://api.useautumn.com";
+var DEFAULT_CONFIG = `import {
+	feature,
+	product,
+	priceItem,
+	featureItem,
+	pricedFeatureItem,
+} from 'atmn';
+
+const seats = feature({
+	id: 'seats',
+	name: 'Seats',
+	type: 'continuous_use',
+});
+
+const messages = feature({
+	id: 'messages',
+	name: 'Messages',
+	type: 'single_use',
+});
+
+const pro = product({
+	id: 'pro',
+	name: 'Pro',
+	items: [
+		// 500 messages per month
+		featureItem({
+			feature_id: messages.id,
+			included_usage: 500,
+			interval: 'month',
+		}),
+
+		// $10 per seat per month
+		pricedFeatureItem({
+			feature_id: seats.id,
+			price: 10,
+			interval: 'month',
+		}),
+
+		// $50 / month
+		priceItem({
+			price: 50,
+			interval: 'month',
+		}),
+	],
+});
+
+const autumnConfig = {
+	features: [seats, messages],
+	products: [pro],
+};
+
+export default autumnConfig;
+`;
+function snakeCaseToCamelCase(value) {
+  return value.replace(/_([a-z])/g, (match, letter) => letter.toUpperCase());
+}
+function idToVar(id) {
+  return id.replace(/[-_](.)/g, (_, letter) => letter.toUpperCase()).replace(/^[^a-zA-Z_$]/, "_").replace(/[^a-zA-Z0-9_$]/g, "");
+}
+function storeToEnv(prodKey, sandboxKey) {
+  const envPath = `${process.cwd()}/.env`;
+  const envVars = `# AUTUMN_SECRET_KEY=${prodKey}
+AUTUMN_SECRET_KEY=${sandboxKey}
+`;
+  if (fs__default.default.existsSync(envPath)) {
+    fs__default.default.appendFileSync(envPath, envVars);
+    console.log(chalk6__default.default.green(".env file found. Appended keys."));
+  } else {
+    fs__default.default.writeFileSync(envPath, envVars);
+    console.log(chalk6__default.default.green(".env file not found. Created new .env file and wrote keys."));
+  }
+}
+function readFromEnv() {
+  const envPath = `${process.cwd()}/.env`;
+  if (!fs__default.default.existsSync(envPath)) {
+    return void 0;
+  }
+  const envContent = fs__default.default.readFileSync(envPath, "utf-8");
+  const match = envContent.match(/^AUTUMN_SECRET_KEY=(.*)$/m);
+  return match ? match[1] : void 0;
+}
+
+// source/core/api.ts
+var INTERNAL_BASE = BACKEND_URL;
+var EXTERNAL_BASE = `${BACKEND_URL}/v1`;
+async function request({
+  method,
+  base,
+  path: path2,
+  data,
+  headers,
+  customAuth,
+  throwOnError = true
+}) {
+  const apiKey = readFromEnv();
+  try {
+    const response = await axios__default.default.request({
+      method,
+      url: `${base}${path2}`,
+      data,
+      headers: {
+        "Content-Type": "application/json",
+        ...headers,
+        Authorization: customAuth || `Bearer ${apiKey}`
+      }
+    });
+    return response.data;
+  } catch (error) {
+    if (throwOnError) {
+      throw error;
+    }
+    console.error(
+      chalk6__default.default.red("Error occured when making API request:"),
+      chalk6__default.default.red(error.response.data.message || error.response.data.error)
+    );
+    process.exit(1);
+  }
+}
+async function internalRequest({
+  method,
+  path: path2,
+  data,
+  headers,
+  customAuth
+}) {
+  return await request({
+    method,
+    base: INTERNAL_BASE,
+    path: path2,
+    data,
+    headers,
+    customAuth
+  });
+}
+async function externalRequest({
+  method,
+  path: path2,
+  data,
+  headers,
+  customAuth,
+  throwOnError = false
+}) {
+  return await request({
+    method,
+    base: EXTERNAL_BASE,
+    path: path2,
+    data,
+    headers,
+    customAuth,
+    throwOnError
+  });
+}
+async function deleteFeature(id) {
+  return await externalRequest({
+    method: "DELETE",
+    path: `/features/${id}`
+  });
+}
+async function deleteProduct(id) {
+  return await externalRequest({
+    method: "DELETE",
+    path: `/products/${id}`
+  });
+}
+async function updateCLIStripeKeys(stripeTestKey, stripeLiveKey, stripeFlowAuthKey) {
+  return await internalRequest({
+    method: "POST",
+    path: "/dev/cli/stripe",
+    data: {
+      stripeTestKey,
+      stripeLiveKey,
+      successUrl: "https://useautumn.com",
+      defaultCurrency: "usd"
+    },
+    customAuth: stripeFlowAuthKey
+  });
+}
+
+// source/core/pull.ts
+async function getAllProducts() {
+  const { list } = await externalRequest({
+    method: "GET",
+    path: "/products"
+  });
+  return list.map((product) => product);
+}
+async function getFeatures() {
+  const { list } = await externalRequest({
+    method: "GET",
+    path: "/features"
+  });
+  return list.map((feature) => feature);
+}
+
+// source/core/builders/products.ts
+var ItemBuilders = {
+  priced_feature: pricedFeatureItemBuilder,
+  feature: featureItemBuilder,
+  price: priceItemBuilder
+};
+function importBuilder() {
+  return `
+import {
+	feature,
+	product,
+	featureItem,
+	pricedFeatureItem,
+	priceItem,
+} from 'atmn';
+    `;
+}
+function exportBuilder(productIds, featureIds) {
+  const snippet = `
+const autumnConfig = {
+    products: [${productIds.map((id) => `${idToVar(id)}`).join(", ")}],
+    features: [${featureIds.map((id) => `${idToVar(id)}`).join(", ")}]
+}
+
+export default autumnConfig;
+    `;
+  return snippet;
+}
+function productBuilder(product) {
+  const snippet = `
+export const ${idToVar(product.id)} = product({
+    id: '${product.id}',
+    name: '${product.name}',
+    items: [${product.items.map(
+    (item) => `${ItemBuilders[item.type](item)}`
+  ).join("           ")}     ]
+})
+`;
+  return snippet;
+}
+function pricedFeatureItemBuilder(item) {
+  const intervalLine = item.interval == null ? "" : `
+            interval: '${item.interval}',`;
+  const snippet = `
+        pricedFeatureItem({
+            feature_id: ${idToVar(item.feature_id)}.id,
+            price: ${item.price},${intervalLine}
+            included_usage: ${item.included_usage},
+            billing_units: ${item.billing_units},
+            usage_model: '${item.usage_model}',
+        }),
+`;
+  return snippet;
+}
+function featureItemBuilder(item) {
+  const intervalLine = item.interval == null ? "" : `
+            interval: '${item.interval}',`;
+  const snippet = `
+        featureItem({
+            feature_id: ${idToVar(item.feature_id)}.id,
+            included_usage: ${item.included_usage},${intervalLine}
+        }),
+`;
+  return snippet;
+}
+function priceItemBuilder(item) {
+  const intervalLine = item.interval == null ? "" : `
+            interval: '${item.interval}',`;
+  const snippet = `
+        priceItem({
+            price: ${item.price},${intervalLine}
+        }),
+`;
+  return snippet;
+}
+
+// source/core/builders/features.ts
+function featureBuilder(feature) {
+  const snippet = `
+export const ${idToVar(feature.id)} = feature({
+    id: '${feature.id}',
+    name: '${feature.name}',
+    type: '${feature.type}',
+})`;
+  return snippet;
+}
+async function loadAutumnConfigFile() {
+  const configPath = path__default.default.join(process.cwd(), "autumn.config.ts");
+  const absolutePath = path.resolve(configPath);
+  const fileUrl = url.pathToFileURL(absolutePath).href;
+  const jiti = createJiti__default.default(importMetaUrl);
+  const mod = await jiti.import(fileUrl);
+  const def = mod.default || mod;
+  if (!def.products || !Array.isArray(def.products)) {
+    throw new Error(
+      "You must export a products field that is an array of products."
+    );
+  }
+  if (!def.features || !Array.isArray(def.features)) {
+    throw new Error(
+      "You must export a features field that is an array of products."
+    );
+  }
+  return def;
+}
+function writeConfig(config) {
+  const configPath = path__default.default.join(process.cwd(), "autumn.config.ts");
+  fs__default.default.writeFileSync(configPath, config);
+}
+
+// source/commands/pull.ts
+async function Pull({ config }) {
+  console.log(chalk6__default.default.green("Pulling products and features from Autumn..."));
+  const products = await getAllProducts();
+  const features = await getFeatures();
+  const productSnippets = products.map(
+    (product) => productBuilder(product)
+  );
+  const featureSnippets = features.map(
+    (feature) => featureBuilder(feature)
+  );
+  const autumnConfig = `
+${importBuilder()}
+
+// Features
+${featureSnippets.join("\n")}
+
+// Products
+${productSnippets.join("\n")}
+
+// Remember to update this when you make changes!
+${exportBuilder(
+    products.map((product) => product.id),
+    features.map((feature) => snakeCaseToCamelCase(feature.id))
+  )}
+	`;
+  writeConfig(autumnConfig);
+  console.log(chalk6__default.default.green("Success! Config has been updated."));
+}
+
+// source/core/auth.ts
+async function getOTP(otp) {
+  const response = await internalRequest({
+    method: "GET",
+    path: `/dev/otp/${otp}`
+  });
+  return response;
+}
+
+// source/commands/auth.ts
+var passwordTheme = {
+  style: {
+    answer: (text) => {
+      return chalk6__default.default.magenta("*".repeat(text.length));
+    }
+  }
+};
+var inputTheme = {
+  style: {
+    answer: (text) => {
+      return chalk6__default.default.magenta(text);
+    }
+  }
+};
+async function AuthCommand() {
+  if (readFromEnv()) {
+    let shouldReauth = await prompts.confirm({
+      message: "You are already authenticated. Would you like to re-authenticate?",
+      theme: inputTheme
+    });
+    if (!shouldReauth) {
+      return;
+    }
+  }
+  open__default.default(`${FRONTEND_URL}/dev/cli`);
+  const otp = await prompts.input({
+    message: "Enter OTP:",
+    theme: inputTheme
+  });
+  const keyInfo = await getOTP(otp);
+  if (!keyInfo.stripe_connected) {
+    let connectStripe = await prompts.confirm({
+      message: "It seems like your organization doesn't have any Stripe keys connected. Would you like to connect them now?",
+      theme: inputTheme
+    });
+    if (connectStripe) {
+      let stripeTestKey = await prompts.password({
+        message: "Enter Stripe Test Secret Key:",
+        mask: "*",
+        theme: passwordTheme
+      });
+      await updateCLIStripeKeys(
+        stripeTestKey,
+        stripeTestKey,
+        keyInfo.stripeFlowAuthKey
+      );
+    } else {
+      console.log(
+        chalk6__default.default.yellow(
+          "Okay, no worries. Go to the Autumn dashboard when you're ready!"
+        )
+      );
+    }
+  }
+  storeToEnv(keyInfo.prodKey, keyInfo.sandboxKey);
+  console.log(
+    chalk6__default.default.green(
+      "Success! Keys have been stored locally. You may now use the CLI."
+    )
+  );
+}
+
+// source/commands/init.ts
+async function Init({ config }) {
+  let apiKey = readFromEnv();
+  if (apiKey) {
+    console.log(chalk6__default.default.green("API key found. Pulling latest config..."));
+    await Pull({ config });
+    console.log(chalk6__default.default.green("Project initialized and config pulled successfully!"));
+    return;
+  }
+  console.log(chalk6__default.default.yellow("No API key found. Running authentication..."));
+  await AuthCommand();
+  apiKey = readFromEnv();
+  if (apiKey) {
+    await Pull({ config });
+    console.log(chalk6__default.default.green("Project initialized! You are now authenticated and config has been pulled."));
+  } else {
+    console.log(chalk6__default.default.red("Authentication did not yield an API key. Please check your setup."));
+  }
+}
+
+// source/core/push.ts
+async function checkForDeletables(currentFeatures, currentProducts) {
+  const features = await getFeatures();
+  const featureIds = features.map((feature) => feature.id);
+  const currentFeatureIds = currentFeatures.map((feature) => feature.id);
+  const featuresToDelete = featureIds.filter(
+    (featureId) => !currentFeatureIds.includes(featureId)
+  );
+  const products = await getAllProducts();
+  const productIds = products.map((product) => product.id);
+  const currentProductIds = currentProducts.map((product) => product.id);
+  const productsToDelete = productIds.filter(
+    (productId) => !currentProductIds.includes(productId)
+  );
+  return { featuresToDelete, productsToDelete };
+}
+async function upsertFeature(feature) {
+  try {
+    const response = await externalRequest({
+      method: "POST",
+      path: `/features`,
+      data: feature,
+      throwOnError: true
+      // data: {
+      // 	...feature,
+      // 	config: {
+      // 		filters: [{property: '', operator: '', value: []}],
+      // 		usage_type: 'single_use',
+      // 	},
+      // },
+    });
+    return response.data;
+  } catch (error) {
+    const response = await externalRequest({
+      method: "POST",
+      path: `/features/${feature.id}`,
+      data: feature
+      // data: {
+      // 	...feature,
+      // 	config: {
+      // 		filters: [{property: '', operator: '', value: []}],
+      // 		usage_type: 'single_use',
+      // 	},
+      // },
+    });
+    return response.data;
+  }
+}
+async function upsertProduct(product) {
+  try {
+    const response = await externalRequest({
+      method: "POST",
+      path: `/products`,
+      data: product,
+      throwOnError: true
+    });
+    return response.data;
+  } catch (error) {
+    const response = await externalRequest({
+      method: "POST",
+      path: `/products/${product.id}`,
+      data: product
+    });
+    return response.data;
+  }
+}
+
+// source/commands/push.ts
+async function Push({
+  config,
+  yes,
+  prod
+}) {
+  let { features, products } = config;
+  let { featuresToDelete, productsToDelete } = await checkForDeletables(
+    features,
+    products
+  );
+  for (let productId of productsToDelete) {
+    let shouldDelete = yes || await prompts.confirm({
+      message: `Delete product [${productId}]?`
+    });
+    if (shouldDelete) {
+      await deleteProduct(productId);
+      console.log(chalk6__default.default.green(`Product [${productId}] deleted successfully!`));
+    }
+  }
+  for (let feature of features) {
+    console.log(chalk6__default.default.green(`Pushing feature [${feature.id}]`));
+    await upsertFeature(feature);
+    console.log(chalk6__default.default.green(`Pushed feature [${feature.id}]`));
+  }
+  for (let product of products) {
+    console.log(chalk6__default.default.green(`Pushing product [${product.id}]`));
+    await upsertProduct(product);
+    console.log(chalk6__default.default.green(`Pushed product [${product.id}]`));
+  }
+  for (let featureId of featuresToDelete) {
+    let shouldDelete = yes || await prompts.confirm({
+      message: `Delete feature [${featureId}]?`
+    });
+    if (shouldDelete) {
+      await deleteFeature(featureId);
+      console.log(chalk6__default.default.green(`Feature [${featureId}] deleted successfully!`));
+    }
+  }
+  const env = prod ? "prod" : "sandbox";
+  console.log(
+    chalk6__default.default.magentaBright(`Success! Changes have been pushed to ${env}.`)
+  );
+  if (prod) {
+    console.log(
+      chalk6__default.default.magentaBright(
+        `You can view the products at ${FRONTEND_URL}/products`
+      )
+    );
+  } else {
+    console.log(
+      chalk6__default.default.magentaBright(
+        `You can view the products at ${FRONTEND_URL}/sandbox/products`
+      )
+    );
+  }
+}
+var VERSION = "1.0.0b";
+commander.program.command("push").description("Push changes to Autumn").option("-p, --prod", "Push to production").option("-y, --yes", "Confirm all deletions").action(async (options) => {
+  const config = await loadAutumnConfigFile();
+  await Push({ config, yes: options.yes, prod: options.prod });
+});
+commander.program.command("pull").description("Pull changes from Autumn").option("-p, --prod", "Pull from production").action(async () => {
+  const config = await loadAutumnConfigFile();
+  await Pull({ config });
+});
+commander.program.command("init").description("Initialize an Autumn project.").action(async () => {
+  writeConfig(DEFAULT_CONFIG);
+  const config = await loadAutumnConfigFile();
+  await Init({ config });
+});
+commander.program.command("login").description("Authenticate with Autumn").option("-p, --prod", "Authenticate with production").action(async () => {
+  await AuthCommand();
+});
+commander.program.command("dashboard").description("Open the Autumn dashboard in your browser").action(() => {
+  open__default.default(`${FRONTEND_URL}`);
+});
+commander.program.command("version").description("Show the version of Autumn").action(() => {
+  console.log(chalk6__default.default.green(`Autumn v${VERSION}`));
+});
+commander.program.parse();

package/dist/cli.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.d.ts

@@ -1,2 +1 @@
 #!/usr/bin/env node
-export {};