@ebowwa/hetzner 0.1.0 → 0.2.0

package/pricing.js

@@ -1,53 +1,98 @@
+"use strict";
 /**
  * Hetzner pricing operations - fetch server types, locations, and calculate costs
  */
-import { z } from "zod";
-import { HetznerListServerTypesResponseSchema, HetznerListLocationsResponseSchema, HetznerListDatacentersResponseSchema, } from "./schemas.js";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PricingOperations = exports.CostCalculationResultSchema = exports.EnvironmentCostSchema = exports.ServerTypePriceSchema = void 0;
+exports.parseHetznerPrice = parseHetznerPrice;
+exports.extractServerTypePrice = extractServerTypePrice;
+exports.buildPriceMap = buildPriceMap;
+exports.getServerTypeMonthlyPrice = getServerTypeMonthlyPrice;
+exports.calculateHourlyFromMonthly = calculateHourlyFromMonthly;
+exports.calculateCosts = calculateCosts;
+var zod_1 = require("zod");
+var schemas_js_1 = require("./schemas.js");
 /**
  * Default fallback price for unknown server types (EUR/month)
  * Conservative estimate based on Hetzner's smallest standard server
  */
-const DEFAULT_FALLBACK_PRICE_MONTHLY = 5.0;
+var DEFAULT_FALLBACK_PRICE_MONTHLY = 5.0;
 /**
  * Hours per month for hourly cost calculation
  * Using 730 hours (average month: 365.25 days * 24 hours / 12 months)
  */
-const HOURS_PER_MONTH = 730;
+var HOURS_PER_MONTH = 730;
 // ============================================================================
 // Zod Schemas for Cost Calculation
 // ============================================================================
 /**
  * Schema for server type price entry
  */
-export const ServerTypePriceSchema = z.object({
-    serverType: z.string(),
-    priceMonthly: z.number().nonnegative(),
-    priceHourly: z.number().nonnegative(),
-    deprecated: z.boolean().optional().default(false),
+exports.ServerTypePriceSchema = zod_1.z.object({
+    serverType: zod_1.z.string(),
+    priceMonthly: zod_1.z.number().nonnegative(),
+    priceHourly: zod_1.z.number().nonnegative(),
+    deprecated: zod_1.z.boolean().optional().default(false),
 });
 /**
  * Schema for environment cost entry
  */
-export const EnvironmentCostSchema = z.object({
-    environmentId: z.string(),
-    environmentName: z.string(),
-    serverType: z.string(),
-    isRunning: z.boolean(),
-    costMonthly: z.number().nonnegative(),
-    costHourly: z.number().nonnegative(),
-    priceInfo: ServerTypePriceSchema.optional(),
+exports.EnvironmentCostSchema = zod_1.z.object({
+    environmentId: zod_1.z.string(),
+    environmentName: zod_1.z.string(),
+    serverType: zod_1.z.string(),
+    isRunning: zod_1.z.boolean(),
+    costMonthly: zod_1.z.number().nonnegative(),
+    costHourly: zod_1.z.number().nonnegative(),
+    priceInfo: exports.ServerTypePriceSchema.optional(),
 });
 /**
  * Schema for cost calculation result
  */
-export const CostCalculationResultSchema = z.object({
-    totalMonthly: z.number().nonnegative(),
-    totalHourly: z.number().nonnegative(),
-    runningEnvironmentCount: z.number().nonnegative().int(),
-    stoppedEnvironmentCount: z.number().nonnegative().int(),
-    unknownServerTypeCount: z.number().nonnegative().int(),
-    breakdown: z.array(EnvironmentCostSchema),
-    priceMap: z.custom(),
+exports.CostCalculationResultSchema = zod_1.z.object({
+    totalMonthly: zod_1.z.number().nonnegative(),
+    totalHourly: zod_1.z.number().nonnegative(),
+    runningEnvironmentCount: zod_1.z.number().nonnegative().int(),
+    stoppedEnvironmentCount: zod_1.z.number().nonnegative().int(),
+    unknownServerTypeCount: zod_1.z.number().nonnegative().int(),
+    breakdown: zod_1.z.array(exports.EnvironmentCostSchema),
+    priceMap: zod_1.z.custom(),
 });
 // ============================================================================
 // Cost Calculation Utilities
@@ -59,10 +104,10 @@ export const CostCalculationResultSchema = z.object({
  * @param priceString - Price string from Hetzner API (gross field)
  * @returns Price in EUR as number
  */
-export function parseHetznerPrice(priceString) {
-    const parsed = parseFloat(priceString);
+function parseHetznerPrice(priceString) {
+    var parsed = parseFloat(priceString);
     if (isNaN(parsed)) {
-        console.warn(`Failed to parse Hetzner price string: ${priceString}`);
+        console.warn("Failed to parse Hetzner price string: ".concat(priceString));
         return 0;
     }
     return parsed;
@@ -74,20 +119,21 @@ export function parseHetznerPrice(priceString) {
  * @param serverType - Hetzner server type object
  * @returns Server type price info or undefined if pricing unavailable
  */
-export function extractServerTypePrice(serverType) {
+function extractServerTypePrice(serverType) {
+    var _a;
     if (!serverType.prices || serverType.prices.length === 0) {
-        console.warn(`Server type ${serverType.name} has no pricing information`);
+        console.warn("Server type ".concat(serverType.name, " has no pricing information"));
         return undefined;
     }
     // Use first price entry (Hetzner API returns location-agnostic pricing first)
-    const priceEntry = serverType.prices[0];
-    const priceMonthly = parseHetznerPrice(priceEntry.price_monthly.gross);
-    const priceHourly = parseHetznerPrice(priceEntry.price_hourly.gross);
+    var priceEntry = serverType.prices[0];
+    var priceMonthly = parseHetznerPrice(priceEntry.price_monthly.gross);
+    var priceHourly = parseHetznerPrice(priceEntry.price_hourly.gross);
     return {
         serverType: serverType.name,
-        priceMonthly,
-        priceHourly,
-        deprecated: serverType.deprecated ?? false,
+        priceMonthly: priceMonthly,
+        priceHourly: priceHourly,
+        deprecated: (_a = serverType.deprecated) !== null && _a !== void 0 ? _a : false,
     };
 }
 /**
@@ -96,10 +142,11 @@ export function extractServerTypePrice(serverType) {
  * @param serverTypes - Array of Hetzner server types
  * @returns Map of server type name to price info
  */
-export function buildPriceMap(serverTypes) {
-    const priceMap = new Map();
-    for (const serverType of serverTypes) {
-        const priceInfo = extractServerTypePrice(serverType);
+function buildPriceMap(serverTypes) {
+    var priceMap = new Map();
+    for (var _i = 0, serverTypes_1 = serverTypes; _i < serverTypes_1.length; _i++) {
+        var serverType = serverTypes_1[_i];
+        var priceInfo = extractServerTypePrice(serverType);
         if (priceInfo) {
             priceMap.set(serverType.name, priceInfo);
         }
@@ -115,9 +162,11 @@ export function buildPriceMap(serverTypes) {
  * @param fallbackPrice - Fallback price for unknown types (default: 5.0 EUR)
  * @returns Monthly price in EUR
  */
-export function getServerTypeMonthlyPrice(serverTypeName, priceMap, fallbackPrice = DEFAULT_FALLBACK_PRICE_MONTHLY) {
-    const priceInfo = priceMap.get(serverTypeName);
-    return priceInfo?.priceMonthly ?? fallbackPrice;
+function getServerTypeMonthlyPrice(serverTypeName, priceMap, fallbackPrice) {
+    var _a;
+    if (fallbackPrice === void 0) { fallbackPrice = DEFAULT_FALLBACK_PRICE_MONTHLY; }
+    var priceInfo = priceMap.get(serverTypeName);
+    return (_a = priceInfo === null || priceInfo === void 0 ? void 0 : priceInfo.priceMonthly) !== null && _a !== void 0 ? _a : fallbackPrice;
 }
 /**
  * Calculate hourly price from monthly price
@@ -126,7 +175,7 @@ export function getServerTypeMonthlyPrice(serverTypeName, priceMap, fallbackPric
  * @param monthlyPrice - Monthly price in EUR
  * @returns Hourly price in EUR
  */
-export function calculateHourlyFromMonthly(monthlyPrice) {
+function calculateHourlyFromMonthly(monthlyPrice) {
     return monthlyPrice / HOURS_PER_MONTH;
 }
 // ============================================================================
@@ -145,20 +194,23 @@ export function calculateHourlyFromMonthly(monthlyPrice) {
  * @param options - Optional configuration
  * @returns Cost calculation result with totals and breakdown
  */
-export function calculateCosts(environments, serverTypes, options = {}) {
-    const { fallbackPrice = DEFAULT_FALLBACK_PRICE_MONTHLY, includeStopped = false } = options;
+function calculateCosts(environments, serverTypes, options) {
+    var _a, _b;
+    if (options === void 0) { options = {}; }
+    var _c = options.fallbackPrice, fallbackPrice = _c === void 0 ? DEFAULT_FALLBACK_PRICE_MONTHLY : _c, _d = options.includeStopped, includeStopped = _d === void 0 ? false : _d;
     // Build price lookup map
-    const priceMap = buildPriceMap(serverTypes);
+    var priceMap = buildPriceMap(serverTypes);
     // Calculate costs for each environment
-    const breakdown = [];
-    let totalMonthly = 0;
-    let runningCount = 0;
-    let stoppedCount = 0;
-    let unknownTypeCount = 0;
-    for (const env of environments) {
-        const isRunning = env.status === "running";
-        const priceInfo = priceMap.get(env.serverType);
-        const isUnknownType = !priceInfo;
+    var breakdown = [];
+    var totalMonthly = 0;
+    var runningCount = 0;
+    var stoppedCount = 0;
+    var unknownTypeCount = 0;
+    for (var _i = 0, environments_1 = environments; _i < environments_1.length; _i++) {
+        var env = environments_1[_i];
+        var isRunning = env.status === "running";
+        var priceInfo = priceMap.get(env.serverType);
+        var isUnknownType = !priceInfo;
         // Count environments by status
         if (isRunning) {
             runningCount++;
@@ -171,11 +223,11 @@ export function calculateCosts(environments, serverTypes, options = {}) {
             unknownTypeCount++;
         }
         // Get price (use fallback for unknown types, or 0 for stopped environments)
-        const monthlyPrice = isRunning
-            ? (priceInfo?.priceMonthly ?? fallbackPrice)
+        var monthlyPrice = isRunning
+            ? ((_a = priceInfo === null || priceInfo === void 0 ? void 0 : priceInfo.priceMonthly) !== null && _a !== void 0 ? _a : fallbackPrice)
             : 0;
-        const hourlyPrice = isRunning
-            ? (priceInfo?.priceHourly ?? calculateHourlyFromMonthly(fallbackPrice))
+        var hourlyPrice = isRunning
+            ? ((_b = priceInfo === null || priceInfo === void 0 ? void 0 : priceInfo.priceHourly) !== null && _b !== void 0 ? _b : calculateHourlyFromMonthly(fallbackPrice))
             : 0;
         // Add to totals (only running environments)
         if (isRunning) {
@@ -187,7 +239,7 @@ export function calculateCosts(environments, serverTypes, options = {}) {
                 environmentId: env.id,
                 environmentName: env.name,
                 serverType: env.serverType,
-                isRunning,
+                isRunning: isRunning,
                 costMonthly: monthlyPrice,
                 costHourly: hourlyPrice,
                 priceInfo: priceInfo,
@@ -195,78 +247,119 @@ export function calculateCosts(environments, serverTypes, options = {}) {
         }
     }
     // Calculate total hourly from monthly total
-    const totalHourly = calculateHourlyFromMonthly(totalMonthly);
+    var totalHourly = calculateHourlyFromMonthly(totalMonthly);
     return {
-        totalMonthly,
-        totalHourly,
+        totalMonthly: totalMonthly,
+        totalHourly: totalHourly,
         runningEnvironmentCount: runningCount,
         stoppedEnvironmentCount: stoppedCount,
         unknownServerTypeCount: unknownTypeCount,
-        breakdown,
-        priceMap,
+        breakdown: breakdown,
+        priceMap: priceMap,
     };
 }
 // ============================================================================
 // Pricing Operations Class
 // ============================================================================
-export class PricingOperations {
-    client;
-    constructor(client) {
+var PricingOperations = /** @class */ (function () {
+    function PricingOperations(client) {
         this.client = client;
     }
     /**
      * List all server types
      */
-    async listServerTypes() {
-        const response = await this.client.request("/server_types");
-        // Validate response with Zod
-        const validated = HetznerListServerTypesResponseSchema.safeParse(response);
-        if (!validated.success) {
-            console.warn('Hetzner list server types validation warning:', validated.error.issues);
-            return response.server_types; // Return unvalidated data for backward compatibility
-        }
-        return validated.data.server_types;
-    }
+    PricingOperations.prototype.listServerTypes = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, validated;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.client.request("/server_types")];
+                    case 1:
+                        response = _a.sent();
+                        validated = schemas_js_1.HetznerListServerTypesResponseSchema.safeParse(response);
+                        if (!validated.success) {
+                            console.warn('Hetzner list server types validation warning:', validated.error.issues);
+                            return [2 /*return*/, response.server_types]; // Return unvalidated data for backward compatibility
+                        }
+                        return [2 /*return*/, validated.data.server_types];
+                }
+            });
+        });
+    };
     /**
      * Get a specific server type by name
      */
-    async getServerType(name) {
-        const types = await this.listServerTypes();
-        return types.find(t => t.name === name);
-    }
+    PricingOperations.prototype.getServerType = function (name) {
+        return __awaiter(this, void 0, void 0, function () {
+            var types;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.listServerTypes()];
+                    case 1:
+                        types = _a.sent();
+                        return [2 /*return*/, types.find(function (t) { return t.name === name; })];
+                }
+            });
+        });
+    };
     /**
      * List all locations
      */
-    async listLocations() {
-        const response = await this.client.request("/locations");
-        // Validate response with Zod
-        const validated = HetznerListLocationsResponseSchema.safeParse(response);
-        if (!validated.success) {
-            console.warn('Hetzner list locations validation warning:', validated.error.issues);
-            return response.locations; // Return unvalidated data for backward compatibility
-        }
-        return validated.data.locations;
-    }
+    PricingOperations.prototype.listLocations = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, validated;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.client.request("/locations")];
+                    case 1:
+                        response = _a.sent();
+                        validated = schemas_js_1.HetznerListLocationsResponseSchema.safeParse(response);
+                        if (!validated.success) {
+                            console.warn('Hetzner list locations validation warning:', validated.error.issues);
+                            return [2 /*return*/, response.locations]; // Return unvalidated data for backward compatibility
+                        }
+                        return [2 /*return*/, validated.data.locations];
+                }
+            });
+        });
+    };
     /**
      * Get a specific location by name
      */
-    async getLocation(name) {
-        const locations = await this.listLocations();
-        return locations.find(l => l.name === name);
-    }
+    PricingOperations.prototype.getLocation = function (name) {
+        return __awaiter(this, void 0, void 0, function () {
+            var locations;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.listLocations()];
+                    case 1:
+                        locations = _a.sent();
+                        return [2 /*return*/, locations.find(function (l) { return l.name === name; })];
+                }
+            });
+        });
+    };
     /**
      * List all datacenters
      */
-    async listDatacenters() {
-        const response = await this.client.request("/datacenters");
-        // Validate response with Zod
-        const validated = HetznerListDatacentersResponseSchema.safeParse(response);
-        if (!validated.success) {
-            console.warn('Hetzner list datacenters validation warning:', validated.error.issues);
-            return response.datacenters; // Return unvalidated data for backward compatibility
-        }
-        return validated.data.datacenters;
-    }
+    PricingOperations.prototype.listDatacenters = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, validated;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.client.request("/datacenters")];
+                    case 1:
+                        response = _a.sent();
+                        validated = schemas_js_1.HetznerListDatacentersResponseSchema.safeParse(response);
+                        if (!validated.success) {
+                            console.warn('Hetzner list datacenters validation warning:', validated.error.issues);
+                            return [2 /*return*/, response.datacenters]; // Return unvalidated data for backward compatibility
+                        }
+                        return [2 /*return*/, validated.data.datacenters];
+                }
+            });
+        });
+    };
     /**
      * Calculate costs for environments using current Hetzner pricing
      *
@@ -276,9 +369,19 @@ export class PricingOperations {
      * @param options - Optional configuration for cost calculation
      * @returns Cost calculation result
      */
-    async calculateEnvironmentCosts(environments, options) {
-        const serverTypes = await this.listServerTypes();
-        return calculateCosts(environments, serverTypes, options);
-    }
-}
-//# sourceMappingURL=pricing.js.map
+    PricingOperations.prototype.calculateEnvironmentCosts = function (environments, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var serverTypes;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.listServerTypes()];
+                    case 1:
+                        serverTypes = _a.sent();
+                        return [2 /*return*/, calculateCosts(environments, serverTypes, options)];
+                }
+            });
+        });
+    };
+    return PricingOperations;
+}());
+exports.PricingOperations = PricingOperations;