atmn 0.0.4 → 0.0.6

package/dist/cli.js

@@ -1,58 +1,588 @@
 #!/usr/bin/env node
 import { program } from 'commander';
-import Init from './commands/init.js';
-import { loadAutumnConfigFile } from './core/config.js';
-import Push from './commands/push.js';
-import Pull from './commands/pull.js';
-import AuthCommand from './commands/auth.js';
+import chalk6 from 'chalk';
+import axios from 'axios';
+import fs from 'fs';
+import path, { resolve } from 'path';
+import createJiti from 'jiti';
+import { pathToFileURL } from 'url';
 import open from 'open';
-import chalk from 'chalk';
-import { writeConfig } from './core/config.js';
-import { FRONTEND_URL } from './constants.js';
-import { DEFAULT_CONFIG } from './constants.js';
-const VERSION = '1.0.0b';
-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 });
-});
-program
-    .command('pull')
-    .description('Pull changes from Autumn')
-    .option('-p, --prod', 'Pull from production')
-    .action(async () => {
-    const config = await loadAutumnConfigFile();
+import { confirm, input, password } from '@inquirer/prompts';
+
+// 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.existsSync(envPath)) {
+    fs.appendFileSync(envPath, envVars);
+    console.log(chalk6.green(".env file found. Appended keys."));
+  } else {
+    fs.writeFileSync(envPath, envVars);
+    console.log(chalk6.green(".env file not found. Created new .env file and wrote keys."));
+  }
+}
+function readFromEnv() {
+  const envPath = `${process.cwd()}/.env`;
+  if (!fs.existsSync(envPath)) {
+    return void 0;
+  }
+  const envContent = fs.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.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.red("Error occured when making API request:"),
+      chalk6.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.join(process.cwd(), "autumn.config.ts");
+  const absolutePath = resolve(configPath);
+  const fileUrl = pathToFileURL(absolutePath).href;
+  const jiti = createJiti(import.meta.url);
+  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.join(process.cwd(), "autumn.config.ts");
+  fs.writeFileSync(configPath, config);
+}
+
+// source/commands/pull.ts
+async function Pull({ config }) {
+  console.log(chalk6.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.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.magenta("*".repeat(text.length));
+    }
+  }
+};
+var inputTheme = {
+  style: {
+    answer: (text) => {
+      return chalk6.magenta(text);
+    }
+  }
+};
+async function AuthCommand() {
+  if (readFromEnv()) {
+    let shouldReauth = await confirm({
+      message: "You are already authenticated. Would you like to re-authenticate?",
+      theme: inputTheme
+    });
+    if (!shouldReauth) {
+      return;
+    }
+  }
+  open(`${FRONTEND_URL}/dev/cli`);
+  const otp = await input({
+    message: "Enter OTP:",
+    theme: inputTheme
+  });
+  const keyInfo = await getOTP(otp);
+  if (!keyInfo.stripe_connected) {
+    let connectStripe = await 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 password({
+        message: "Enter Stripe Test Secret Key:",
+        mask: "*",
+        theme: passwordTheme
+      });
+      await updateCLIStripeKeys(
+        stripeTestKey,
+        stripeTestKey,
+        keyInfo.stripeFlowAuthKey
+      );
+    } else {
+      console.log(
+        chalk6.yellow(
+          "Okay, no worries. Go to the Autumn dashboard when you're ready!"
+        )
+      );
+    }
+  }
+  storeToEnv(keyInfo.prodKey, keyInfo.sandboxKey);
+  console.log(
+    chalk6.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.green("API key found. Pulling latest config..."));
+    await Pull({ config });
+    console.log(chalk6.green("Project initialized and config pulled successfully!"));
+    return;
+  }
+  console.log(chalk6.yellow("No API key found. Running authentication..."));
+  await AuthCommand();
+  apiKey = readFromEnv();
+  if (apiKey) {
     await Pull({ config });
+    console.log(chalk6.green("Project initialized! You are now authenticated and config has been pulled."));
+  } else {
+    console.log(chalk6.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 confirm({
+      message: `Delete product [${productId}]?`
+    });
+    if (shouldDelete) {
+      await deleteProduct(productId);
+      console.log(chalk6.green(`Product [${productId}] deleted successfully!`));
+    }
+  }
+  for (let feature of features) {
+    console.log(chalk6.green(`Pushing feature [${feature.id}]`));
+    await upsertFeature(feature);
+    console.log(chalk6.green(`Pushed feature [${feature.id}]`));
+  }
+  for (let product of products) {
+    console.log(chalk6.green(`Pushing product [${product.id}]`));
+    await upsertProduct(product);
+    console.log(chalk6.green(`Pushed product [${product.id}]`));
+  }
+  for (let featureId of featuresToDelete) {
+    let shouldDelete = yes || await confirm({
+      message: `Delete feature [${featureId}]?`
+    });
+    if (shouldDelete) {
+      await deleteFeature(featureId);
+      console.log(chalk6.green(`Feature [${featureId}] deleted successfully!`));
+    }
+  }
+  const env = prod ? "prod" : "sandbox";
+  console.log(
+    chalk6.magentaBright(`Success! Changes have been pushed to ${env}.`)
+  );
+  if (prod) {
+    console.log(
+      chalk6.magentaBright(
+        `You can view the products at ${FRONTEND_URL}/products`
+      )
+    );
+  } else {
+    console.log(
+      chalk6.magentaBright(
+        `You can view the products at ${FRONTEND_URL}/sandbox/products`
+      )
+    );
+  }
+}
+var VERSION = "1.0.0b";
+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 });
+});
+program.command("pull").description("Pull changes from Autumn").option("-p, --prod", "Pull from production").action(async () => {
+  const config = await loadAutumnConfigFile();
+  await Pull({ config });
+});
+program.command("init").description("Initialize an Autumn project.").action(async () => {
+  writeConfig(DEFAULT_CONFIG);
+  const config = await loadAutumnConfigFile();
+  await Init({ config });
+});
+program.command("login").description("Authenticate with Autumn").option("-p, --prod", "Authenticate with production").action(async () => {
+  await AuthCommand();
+});
+program.command("dashboard").description("Open the Autumn dashboard in your browser").action(() => {
+  open(`${FRONTEND_URL}`);
 });
-program
-    .command('init')
-    .description('Initialize an Autumn project.')
-    .action(async () => {
-    writeConfig(DEFAULT_CONFIG); // just write an empty config to make the config file.
-    const config = await loadAutumnConfigFile();
-    await Init({ config });
-});
-program
-    .command('login')
-    .description('Authenticate with Autumn')
-    .option('-p, --prod', 'Authenticate with production')
-    .action(async () => {
-    await AuthCommand();
-});
-program
-    .command('dashboard')
-    .description('Open the Autumn dashboard in your browser')
-    .action(() => {
-    open(`${FRONTEND_URL}`);
-});
-program
-    .command('version')
-    .description('Show the version of Autumn')
-    .action(() => {
-    console.log(chalk.green(`Autumn v${VERSION}`));
+program.command("version").description("Show the version of Autumn").action(() => {
+  console.log(chalk6.green(`Autumn v${VERSION}`));
 });
 program.parse();

package/dist/index.cjs

@@ -0,0 +1,48 @@
+'use strict';
+
+// source/compose/builders/builderFunctions.ts
+var product = (p) => p;
+var feature = (f) => f;
+var featureItem = ({
+  feature_id,
+  included_usage,
+  interval
+}) => {
+  return {
+    included_usage,
+    feature_id,
+    interval
+  };
+};
+var priceItem = ({
+  price,
+  interval
+}) => {
+  return {
+    price,
+    interval
+  };
+};
+var pricedFeatureItem = ({
+  feature_id,
+  price,
+  interval,
+  included_usage = void 0,
+  billing_units = 1,
+  usage_model = "pay_per_use"
+}) => {
+  return {
+    price,
+    interval,
+    billing_units,
+    feature_id,
+    usage_model,
+    included_usage
+  };
+};
+
+exports.feature = feature;
+exports.featureItem = featureItem;
+exports.priceItem = priceItem;
+exports.pricedFeatureItem = pricedFeatureItem;
+exports.product = product;