atmn 0.0.4 → 0.0.6

package/dist/constants.js

@@ -1,55 +0,0 @@
-// export const FRONTEND_URL = 'http://localhost:3000';
-// export const BACKEND_URL = 'http://localhost:8080';
-export const FRONTEND_URL = 'http://app.useautumn.com';
-export const BACKEND_URL = 'https://api.useautumn.com';
-export const DEFAULT_CONFIG = `import {
-	feature,
-	product,
-	priceItem,
-	featureItem,
-	pricedFeatureItem,
-} from 'autumn-js/compose';
-
-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',
-		}),
-	],
-});
-
-export default {
-	features: [seats, messages],
-	products: [pro],
-};
-`;

package/dist/core/api.d.ts

@@ -1,27 +0,0 @@
-export declare function request({ method, base, path, data, headers, customAuth, throwOnError, }: {
-    method: string;
-    base: string;
-    path: string;
-    data?: any;
-    headers?: any;
-    customAuth?: string;
-    throwOnError?: boolean;
-}): Promise<any>;
-export declare function internalRequest({ method, path, data, headers, customAuth, }: {
-    method: string;
-    path: string;
-    data?: any;
-    headers?: any;
-    customAuth?: string;
-}): Promise<any>;
-export declare function externalRequest({ method, path, data, headers, customAuth, throwOnError, }: {
-    method: string;
-    path: string;
-    data?: any;
-    headers?: any;
-    customAuth?: string;
-    throwOnError?: boolean;
-}): Promise<any>;
-export declare function deleteFeature(id: string): Promise<any>;
-export declare function deleteProduct(id: string): Promise<any>;
-export declare function updateCLIStripeKeys(stripeTestKey: string, stripeLiveKey: string, stripeFlowAuthKey: string): Promise<any>;

package/dist/core/api.js

@@ -1,75 +0,0 @@
-import axios from 'axios';
-import chalk from 'chalk';
-import { BACKEND_URL } from '../constants.js';
-import { readFromEnv } from './utils.js';
-const INTERNAL_BASE = BACKEND_URL;
-const EXTERNAL_BASE = `${BACKEND_URL}/v1`;
-export async function request({ method, base, path, data, headers, customAuth, throwOnError = true, }) {
-    const apiKey = readFromEnv();
-    try {
-        const response = await axios.request({
-            method,
-            url: `${base}${path}`,
-            data,
-            headers: {
-                'Content-Type': 'application/json',
-                ...headers,
-                Authorization: customAuth || `Bearer ${apiKey}`,
-            },
-        });
-        return response.data;
-    }
-    catch (error) {
-        if (throwOnError) {
-            throw error;
-        }
-        console.error(chalk.red('Error occured when making API request:'), chalk.red(error.response.data.message || error.response.data.error));
-        process.exit(1);
-    }
-}
-export async function internalRequest({ method, path, data, headers, customAuth, }) {
-    return await request({
-        method,
-        base: INTERNAL_BASE,
-        path,
-        data,
-        headers,
-        customAuth,
-    });
-}
-export async function externalRequest({ method, path, data, headers, customAuth, throwOnError = false, }) {
-    return await request({
-        method,
-        base: EXTERNAL_BASE,
-        path,
-        data,
-        headers,
-        customAuth,
-        throwOnError,
-    });
-}
-export async function deleteFeature(id) {
-    return await externalRequest({
-        method: 'DELETE',
-        path: `/features/${id}`,
-    });
-}
-export async function deleteProduct(id) {
-    return await externalRequest({
-        method: 'DELETE',
-        path: `/products/${id}`,
-    });
-}
-export 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,
-    });
-}

package/dist/core/auth.d.ts

@@ -1 +0,0 @@
-export declare function getOTP(otp: string): Promise<any>;

package/dist/core/auth.js

@@ -1,8 +0,0 @@
-import { internalRequest } from './api.js';
-export async function getOTP(otp) {
-    const response = await internalRequest({
-        method: 'GET',
-        path: `/dev/otp/${otp}`,
-    });
-    return response;
-}

package/dist/core/builders/features.d.ts

@@ -1,2 +0,0 @@
-import { Feature } from 'autumn-js/compose';
-export declare function featureBuilder(feature: Feature): string;

package/dist/core/builders/features.js

@@ -1,10 +0,0 @@
-import { snakeCaseToCamelCase } from '../utils.js';
-export function featureBuilder(feature) {
-    const snippet = `
-export const ${snakeCaseToCamelCase(feature.id)} = feature({
-    id: '${feature.id}',
-    name: '${feature.name}',
-    type: '${feature.type}',
-})`;
-    return snippet;
-}

package/dist/core/builders/products.d.ts

@@ -1,7 +0,0 @@
-import { ProductItem, Product } from 'autumn-js/compose';
-export declare function importBuilder(): string;
-export declare function exportBuilder(productIds: string[], featureIds: string[]): string;
-export declare function productBuilder(product: Product): string;
-export declare function pricedFeatureItemBuilder(item: ProductItem): string;
-export declare function featureItemBuilder(item: ProductItem): string;
-export declare function priceItemBuilder(item: ProductItem): string;

package/dist/core/builders/products.js

@@ -1,71 +0,0 @@
-import { snakeCaseToCamelCase } from '../utils.js';
-const ItemBuilders = {
-    priced_feature: pricedFeatureItemBuilder,
-    feature: featureItemBuilder,
-    price: priceItemBuilder,
-};
-export function importBuilder() {
-    return `
-import {
-	feature,
-	product,
-	featureItem,
-	pricedFeatureItem,
-	priceItem,
-} from 'autumn-js/compose';
-    `;
-}
-export function exportBuilder(productIds, featureIds) {
-    const snippet = `
-export default {
-    products: [${productIds.map(id => `${id}Plan`).join(', ')}],
-    features: [${featureIds.map(id => `${id}`).join(', ')}]
-}
-    `;
-    return snippet;
-}
-export function productBuilder(product) {
-    const snippet = `
-export const ${product.id}Plan = product({
-    id: '${product.id}',
-    name: '${product.name}',
-    items: [${product.items
-        .map((item) => `${ItemBuilders[item.type](item)}`)
-        .join('           ')}     ]
-})
-`;
-    return snippet;
-}
-// Item Builders
-export function pricedFeatureItemBuilder(item) {
-    const intervalLine = item.interval == null ? '' : `\n            interval: '${item.interval}',`;
-    const snippet = `
-        pricedFeatureItem({
-            feature_id: ${snakeCaseToCamelCase(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;
-}
-export function featureItemBuilder(item) {
-    const intervalLine = item.interval == null ? '' : `\n            interval: '${item.interval}',`;
-    const snippet = `
-        featureItem({
-            feature_id: ${snakeCaseToCamelCase(item.feature_id)}.id,
-            included_usage: ${item.included_usage},${intervalLine}
-        }),
-`;
-    return snippet;
-}
-export function priceItemBuilder(item) {
-    const intervalLine = item.interval == null ? '' : `\n            interval: '${item.interval}',`;
-    const snippet = `
-        priceItem({
-            price: ${item.price},${intervalLine}
-        }),
-`;
-    return snippet;
-}

package/dist/core/config.d.ts

@@ -1,2 +0,0 @@
-export declare function loadAutumnConfigFile(): Promise<any>;
-export declare function writeConfig(config: string): void;

package/dist/core/config.js

@@ -1,25 +0,0 @@
-import path from 'path';
-import fs from 'fs';
-import createJiti from 'jiti';
-import { pathToFileURL } from 'url';
-import { resolve } from 'path';
-export async function loadAutumnConfigFile() {
-    const configPath = path.join(process.cwd(), 'autumn.config.ts');
-    const absolutePath = resolve(configPath);
-    const fileUrl = pathToFileURL(absolutePath).href;
-    // Dynamic import the TypeScript config file
-    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;
-}
-export function writeConfig(config) {
-    const configPath = path.join(process.cwd(), 'autumn.config.ts');
-    fs.writeFileSync(configPath, config);
-}

package/dist/core/pull.d.ts

@@ -1,17 +0,0 @@
-export declare function getProducts(ids: string[]): Promise<{
-    id: string;
-    name: string;
-    items: {
-        type?: "feature" | "priced_feature" | null | undefined;
-        feature_id?: string | null | undefined;
-        included_usage?: number | "inf" | null | undefined;
-        interval?: "minute" | "hour" | "day" | "week" | "month" | "quarter" | "semi_annual" | "year" | null | undefined;
-        usage_model?: "prepaid" | "pay_per_use" | null | undefined;
-        price?: number | null | undefined;
-        billing_units?: number | null | undefined;
-    }[];
-    is_add_on?: boolean | undefined;
-    is_default?: boolean | undefined;
-}[]>;
-export declare function getAllProducts(): Promise<any>;
-export declare function getFeatures(): Promise<any>;

package/dist/core/pull.js

@@ -1,22 +0,0 @@
-import { externalRequest } from './api.js';
-export async function getProducts(ids) {
-    const products = await Promise.all(ids.map(id => externalRequest({
-        method: 'GET',
-        path: `/products/${id}`,
-    })));
-    return products.map(product => product);
-}
-export async function getAllProducts() {
-    const { list } = await externalRequest({
-        method: 'GET',
-        path: '/products',
-    });
-    return list.map(product => product);
-}
-export async function getFeatures() {
-    const { list } = await externalRequest({
-        method: 'GET',
-        path: '/features',
-    });
-    return list.map(feature => feature);
-}

package/dist/core/push.d.ts

@@ -1,7 +0,0 @@
-import { Feature, Product } from 'autumn-js/compose';
-export declare function checkForDeletables(currentFeatures: Feature[], currentProducts: Product[]): Promise<{
-    featuresToDelete: any;
-    productsToDelete: any;
-}>;
-export declare function upsertFeature(feature: Feature): Promise<any>;
-export declare function upsertProduct(product: Product): Promise<any>;

package/dist/core/push.js

@@ -1,67 +0,0 @@
-import { externalRequest } from './api.js';
-import { getFeatures, getAllProducts } from './pull.js';
-export async function checkForDeletables(currentFeatures, currentProducts) {
-    const features = await getFeatures(); // Get from AUTUMN
-    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 };
-}
-export 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) {
-        // If the first request fails, try posting to the specific feature ID endpoint
-        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;
-    }
-}
-export async function upsertProduct(product) {
-    try {
-        const response = await externalRequest({
-            method: 'POST',
-            path: `/products`,
-            data: product,
-            throwOnError: true,
-        });
-        return response.data;
-    }
-    catch (error) {
-        // If the first request fails, try posting to the specific product ID endpoint
-        const response = await externalRequest({
-            method: 'POST',
-            path: `/products/${product.id}`,
-            data: product,
-        });
-        return response.data;
-    }
-}

package/dist/core/utils.d.ts

@@ -1,3 +0,0 @@
-export declare function snakeCaseToCamelCase(value: string): string;
-export declare function storeToEnv(prodKey: string, sandboxKey: string): void;
-export declare function readFromEnv(): string;

package/dist/core/utils.js

@@ -1,26 +0,0 @@
-import fs from 'fs';
-import chalk from 'chalk';
-export function snakeCaseToCamelCase(value) {
-    return value.replace(/_([a-z])/g, (match, letter) => letter.toUpperCase());
-}
-export function storeToEnv(prodKey, sandboxKey) {
-    const envPath = `${process.cwd()}/.env`;
-    const envVars = `# AUTUMN_SECRET_KEY=${prodKey}\nAUTUMN_SECRET_KEY=${sandboxKey}\n`;
-    if (fs.existsSync(envPath)) {
-        fs.appendFileSync(envPath, envVars);
-        console.log(chalk.green('.env file found. Appended keys.'));
-    }
-    else {
-        fs.writeFileSync(envPath, envVars);
-        console.log(chalk.green('.env file not found. Created new .env file and wrote keys.'));
-    }
-}
-export function readFromEnv() {
-    const envPath = `${process.cwd()}/.env`;
-    if (!fs.existsSync(envPath)) {
-        return undefined;
-    }
-    const envContent = fs.readFileSync(envPath, 'utf-8');
-    const match = envContent.match(/^AUTUMN_SECRET_KEY=(.*)$/m);
-    return match ? match[1] : undefined;
-}