@villdyr/gigahost-js 0.1.0

package/README.md

@@ -0,0 +1,216 @@
+# gigahost-js
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A zero-dependency TypeScript client for the [Gigahost API](https://gigahost.no/api-dokumentasjon). Manage servers, DNS zones, BGP, .no domains, and more.
+
+- **Zero runtime dependencies** - uses native `fetch`
+- **Full TypeScript** - typed responses and request params
+- **Dual auth** - use a Bearer token or authenticate with username/password
+- **ESM + CommonJS** - works in Node and bundlers
+
+## Installation
+
+```bash
+npm install @villdyr/gigahost-js
+```
+
+## Quick Start
+
+**Option A - Token (e.g. from your own auth flow):**
+
+```typescript
+import { GigahostClient } from "@villdyr/gigahost-js";
+
+const client = new GigahostClient({
+  token: "YOUR_BEARER_TOKEN",
+});
+
+const servers = await client.listServers();
+const zones = await client.listDnsZones();
+```
+
+**Option B - Username + password (client will authenticate for you):**
+
+```typescript
+import { GigahostClient } from "@villdyr/gigahost-js";
+
+const client = new GigahostClient({
+  username: "your@email.com",
+  password: "your-password",
+  // code: 123456,  // if 2FA is enabled
+});
+
+// Token is fetched automatically on first request
+const servers = await client.listServers();
+```
+
+**Get a token explicitly:**
+
+```typescript
+const client = new GigahostClient({ username: "you@example.com", password: "secret" });
+const { token, token_expire, customer_id } = await client.authenticate();
+// Use token elsewhere or keep using the client (it already has the token)
+```
+
+## API Reference
+
+### Constructor
+
+```typescript
+// With token (no automatic auth)
+new GigahostClient({ token: string, baseUrl?: string })
+
+// With credentials (authenticates on first request or when you call authenticate())
+new GigahostClient({ username: string, password: string, code?: number, baseUrl?: string })
+```
+
+| Option     | Type     | Description                                                                 |
+| ---------- | -------- | --------------------------------------------------------------------------- |
+| `token`    | `string` | Bearer token from `POST /authenticate`. Use when you already have a token.  |
+| `username` | `string` | Gigahost account username/email.                                            |
+| `password` | `string` | Account password.                                                           |
+| `code`     | `number` | 2FA code when enabled.                                                      |
+| `baseUrl`  | `string` | Override base URL. Defaults to `https://api.gigahost.no/api/v0`.            |
+
+### Servers
+
+```typescript
+await client.listServers();
+await client.getServer(serverId);
+await client.updateServerName(serverId, "my-server");
+await client.rebootServer(serverId);
+await client.powerOnServer(serverId);
+await client.powerOffServer(serverId);
+await client.getServerPowerState(serverId);
+
+// Snapshots
+await client.listServerSnapshots(serverId);
+await client.createServerSnapshot(serverId, "backup-1");
+await client.deleteServerSnapshot(serverId, snapId);
+
+// KVM/IPMI (session ~3h)
+await client.createServerIpmiSession(serverId, "1.2.3.4;10.0.0.0/24");
+
+// Reinstall
+const distros = await client.listReinstallDistros();
+const osList = await client.listReinstallOs(distroId);
+const { root_passwd, reboot } = await client.reinstallServer(serverId, {
+  os_id: 72,
+  language: "en_US",
+  keyboard: "no",
+  timezone: "Europe/Oslo",
+  hostname: "srv123.gigahost.no",
+});
+
+// Reverse DNS, upgrades, IPs, graphs, ISOs
+await client.updateServerReverse(serverId, { ip_id: 7795, dns: "host.example.com" });
+await client.listServerUpgrades(serverId);
+await client.upgradeServer(serverId, pkgId);
+await client.orderServerIpv4(serverId, "l3");
+await client.getServerPortBits(serverId);   // base64 graphs
+await client.getServerPortUpkts(serverId);
+await client.listServerIsos(serverId);
+await client.mountServerIso(serverId, isoId);
+```
+
+### DNS zones & records
+
+```typescript
+// Zones
+const zones = await client.listDnsZones();
+await client.createDnsZone({ zone_name: "example.no" });
+await client.deleteDnsZone(zoneId);
+
+// Records
+const records = await client.listDnsRecords(zoneId);
+await client.createDnsRecord(zoneId, {
+  record_name: "www",
+  record_type: "A",
+  record_value: "185.125.168.166",
+  record_ttl: 3600,
+});
+await client.updateDnsRecord(zoneId, recordId, { record_value: "1.2.3.4" });
+await client.deleteDnsRecord(zoneId, recordId, "www", "A");
+
+// .no domain registration & registrant
+const check = await client.dnsCheckDomain("example.no");
+await client.registerDomain({ domain_name: "example.no", registrant_type: "organization", ... });
+const registrant = await client.getDnsRegistrant(zoneId);
+await client.updateDnsRegistrant(zoneId, { ... });
+await client.setDnsAutoRenew(zoneId, 1);
+await client.updateDnsNameservers(zoneId, ["ns1.example.com", "ns2.example.com"]);
+await client.updateDnsRegistrantEmail(zoneId, "new@example.com", true);
+
+// Redirects
+await client.listDnsRedirects(zoneId);
+await client.createDnsRedirect(zoneId, { source: "@", target_url: "https://www.example.com" });
+await client.updateDnsRedirect(zoneId, "@", "https://new.example.com");
+await client.deleteDnsRedirect(zoneId, "@");
+
+// DNSSEC, DS records, PTR
+await client.getDnsDsRecords(zoneId);
+await client.setDnsDnssec(zoneId, 1);
+await client.createDnsPtrZone({ prefix: "185.181.63", ip_version: "ipv4", zone_name: "63.181.185.in-addr.arpa" });
+```
+
+### BGP
+
+```typescript
+const bgp = await client.getBgp();  // { asn, prefix_lists, sessions }
+await client.submitBgpAsn("212345");
+await client.createBgpSession(asnId, { redundant: 1, defaultroute: 1, ip_id_v4: "7795", ip_id_v6: "7796" });
+await client.deleteBgpSession(sessionId);
+```
+
+### Account & invoices
+
+```typescript
+const account = await client.getAccount();
+const invoices = await client.listInvoices();
+```
+
+### Lookup helpers
+
+```typescript
+const org = await client.dnsLookupOrganization("123456789");  // Brønnøysund
+const domainCheck = await client.dnsCheckDomain("example.no");
+```
+
+## Error handling
+
+All API errors throw `GigahostError` with `status`, `body`, and optional `messageFromApi`:
+
+```typescript
+import { GigahostClient, GigahostError } from "@villdyr/gigahost-js";
+
+try {
+  await client.getServer(999);
+} catch (err) {
+  if (err instanceof GigahostError) {
+    console.error(err.status);
+    console.error(err.messageFromApi);
+    console.error(err.body);
+  }
+}
+```
+
+## TypeScript
+
+Types are exported for use in your code:
+
+```typescript
+import type {
+  Server,
+  DnsZone,
+  DnsRecord,
+  BgpData,
+  Account,
+  Invoice,
+  GigahostClientOptions,
+} from "@villdyr/gigahost-js";
+```
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,412 @@
+"use strict";
+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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GigahostClient = exports.GigahostError = void 0;
+const DEFAULT_BASE_URL = "https://api.gigahost.no/api/v0";
+class GigahostError extends Error {
+    constructor(message, status, body, messageFromApi) {
+        super(message);
+        this.name = "GigahostError";
+        this.status = status;
+        this.body = body;
+        this.messageFromApi = messageFromApi;
+    }
+}
+exports.GigahostError = GigahostError;
+class GigahostClient {
+    constructor(options) {
+        var _a;
+        this.baseUrl = (_a = options.baseUrl) !== null && _a !== void 0 ? _a : DEFAULT_BASE_URL;
+        if ("token" in options) {
+            if (!options.token)
+                throw new Error("token is required");
+            this.token = options.token;
+            this.credentials = undefined;
+        }
+        else {
+            if (!options.username || !options.password)
+                throw new Error("username and password are required");
+            this.token = null;
+            this.credentials = {
+                username: options.username,
+                password: options.password,
+                code: options.code,
+            };
+        }
+    }
+    authenticate(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const body = params !== null && params !== void 0 ? params : this.credentials;
+            if (!(body === null || body === void 0 ? void 0 : body.username) || !(body === null || body === void 0 ? void 0 : body.password)) {
+                throw new Error("Authenticate requires username and password (pass params or use credential-based constructor)");
+            }
+            const payload = {
+                username: body.username,
+                password: body.password,
+            };
+            if (body.code !== undefined)
+                payload.code = body.code;
+            const res = yield this.requestRaw("POST", "/authenticate", { body: payload });
+            const data = res.data;
+            if (data === null || data === void 0 ? void 0 : data.token) {
+                this.token = data.token;
+            }
+            if (!data)
+                throw new GigahostError("Authentication failed", 401, res);
+            return data;
+        });
+    }
+    ensureToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.token)
+                return this.token;
+            if (this.credentials) {
+                yield this.authenticate();
+                return this.token;
+            }
+            throw new Error("No token available. Use token in constructor or call authenticate() with credentials.");
+        });
+    }
+    requestRaw(method, path, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const url = new URL(`${this.baseUrl}${path}`);
+            if (options === null || options === void 0 ? void 0 : options.params) {
+                for (const [key, value] of Object.entries(options.params)) {
+                    if (value !== undefined)
+                        url.searchParams.set(key, value);
+                }
+            }
+            const headers = {};
+            if (path !== "/authenticate") {
+                headers["Authorization"] = `Bearer ${yield this.ensureToken()}`;
+            }
+            if ((options === null || options === void 0 ? void 0 : options.body) !== undefined) {
+                headers["Content-Type"] = "application/json";
+            }
+            const response = yield fetch(url.toString(), Object.assign({ method,
+                headers }, ((options === null || options === void 0 ? void 0 : options.body) !== undefined ? { body: JSON.stringify(options.body) } : {})));
+            let body;
+            try {
+                const text = yield response.text();
+                body = text ? JSON.parse(text) : undefined;
+            }
+            catch (_b) {
+                body = undefined;
+            }
+            if (!response.ok) {
+                const apiBody = body;
+                throw new GigahostError(`Gigahost API error: ${response.status} ${response.statusText}`, response.status, body, (_a = apiBody === null || apiBody === void 0 ? void 0 : apiBody.meta) === null || _a === void 0 ? void 0 : _a.message);
+            }
+            return (body !== null && body !== void 0 ? body : undefined);
+        });
+    }
+    request(method, path, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.requestRaw(method, path, options);
+            const typed = res;
+            if ((typed === null || typed === void 0 ? void 0 : typed.data) !== undefined)
+                return typed.data;
+            return undefined;
+        });
+    }
+    requestWithMeta(method, path, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.requestRaw(method, path, options);
+        });
+    }
+    getBgp() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request("GET", "/bgp");
+        });
+    }
+    submitBgpAsn(asn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const normalized = typeof asn === "string" && asn.toUpperCase().startsWith("AS") ? asn : String(asn);
+            yield this.requestWithMeta("POST", "/bgp/asn", { body: { asn: normalized } });
+        });
+    }
+    createBgpSession(asnId, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.requestWithMeta("POST", `/bgp/${asnId}/session`, { body: params });
+        });
+    }
+    deleteBgpSession(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.requestWithMeta("DELETE", `/bgp/${sessionId}/session`);
+        });
+    }
+    dnsLookupOrganization(orgNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request("GET", `/dns/lookup/organization/${encodeURIComponent(orgNumber)}`);
+        });
+    }
+    dnsCheckDomain(domain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request("GET", `/dns/domains/check/${encodeURIComponent(domain)}`);
+        });
+    }
+    listDnsZones() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request("GET", "/dns/zones");
+        });
+    }
+    listDnsRecords(zoneId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request("GET", `/dns/zones/${zoneId}/records`);
+        });
+    }
+    getDnsRegistrant(zoneId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request("GET", `/dns/zones/${zoneId}/registrant`);
+        });
+    }
+    registerDomain(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request("POST", "/dns/domains/register", { body: params });
+        });
+    }
+    createDnsZone(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request("POST", "/dns/zones", { body: params });
+        });
+    }
+    createDnsRecord(zoneId, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.requestWithMeta("POST", `/dns/zones/${zoneId}/records`, { body: params });
+        });
+    }
+    updateDnsRecord(zoneId, recordId, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.requestWithMeta("PUT", `/dns/zones/${zoneId}/records/${recordId}`, { body: params });
+        });
+    }
+    updateDnsRegistrant(zoneId, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.requestWithMeta("PUT", `/dns/zones/${zoneId}/registrant`, { body: params });
+        });
+    }
+    setDnsAutoRenew(zoneId, autoRenew) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.requestWithMeta("PUT", `/dns/zones/${zoneId}/auto-renew`, { body: { auto_renew: autoRenew } });
+        });
+    }
+    updateDnsNameservers(zoneId, nameservers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.requestWithMeta("PUT", `/dns/zones/${zoneId}/nameservers`, { body: { nameservers } });
+        });
+    }
+    deleteDnsZone(zoneId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.requestWithMeta("DELETE", `/dns/zones/${zoneId}`);
+        });
+    }
+    deleteDnsRecord(zoneId, recordId, name, type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.requestWithMeta("DELETE", `/dns/zones/${zoneId}/records/${recordId}`, {
+                params: { name, type },
+            });
+        });
+    }
+    getDnsDsRecords(zoneId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request("GET", `/dns/zones/${zoneId}/ds-records`);
+        });
+    }
+    getDnsDsRecordsExternal(zoneId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request("GET", `/dns/zones/${zoneId}/ds-records/external`);
+        });
+    }
+    createDnsPtrZone(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request("POST", "/dns/zones/ptr", { body: params });
+        });
+    }
+    submitDnsDsRecordsExternal(zoneId, dsRecords) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.requestWithMeta("POST", `/dns/zones/${zoneId}/ds-records/external`, { body: { ds_records: dsRecords } });
+        });
+    }
+    setDnsDnssec(zoneId, enable) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.requestWithMeta("PUT", `/dns/zones/${zoneId}/dnssec`, { body: { enable } });
+        });
+    }
+    listDnsRedirects(zoneId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request("GET", `/dns/zones/${zoneId}/redirect`);
+        });
+    }
+    createDnsRedirect(zoneId, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.requestWithMeta("POST", `/dns/zones/${zoneId}/redirect`, { body: params });
+        });
+    }
+    updateDnsRedirect(zoneId, source, targetUrl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.requestWithMeta("PUT", `/dns/zones/${zoneId}/redirect`, { body: { source, target_url: targetUrl } });
+        });
+    }
+    deleteDnsRedirect(zoneId, source) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.requestWithMeta("DELETE", `/dns/zones/${zoneId}/redirect`, { params: { source } });
+        });
+    }
+    updateDnsRegistrantEmail(zoneId, email, enableProtection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.requestWithMeta("PUT", `/dns/zones/${zoneId}/registrant-email`, {
+                body: { email, enable_protection: enableProtection !== null && enableProtection !== void 0 ? enableProtection : false },
+            });
+        });
+    }
+    listServers() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request("GET", "/servers");
+        });
+    }
+    getServer(serverId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.request("GET", `/servers/${serverId}`);
+            return Array.isArray(data) ? data[0] : data;
+        });
+    }
+    updateServerName(serverId, name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.requestWithMeta("PUT", `/servers/${serverId}/name`, { body: { name } });
+        });
+    }
+    createServerIpmiSession(serverId, acl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.request("POST", `/servers/${serverId}/ipmi`, { body: { acl } });
+            return res;
+        });
+    }
+    getServerPowerState(serverId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.requestRaw("GET", `/servers/${serverId}/powerstate`);
+            return { powerstate: res.powerstate, timestamp: res.timestamp };
+        });
+    }
+    rebootServer(serverId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.request("GET", `/servers/${serverId}/reboot`);
+        });
+    }
+    powerOnServer(serverId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.request("GET", `/servers/${serverId}/power/on`);
+        });
+    }
+    powerOffServer(serverId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.request("GET", `/servers/${serverId}/power/off`);
+        });
+    }
+    listServerSnapshots(serverId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request("GET", `/servers/${serverId}/snapshots`);
+        });
+    }
+    createServerSnapshot(serverId, name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.requestWithMeta("POST", `/servers/${serverId}/snapshot`, { body: { name } });
+        });
+    }
+    deleteServerSnapshot(serverId, snapId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.requestWithMeta("DELETE", `/servers/${serverId}/snapshot/${snapId}`);
+        });
+    }
+    getServerPortBits(serverId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request("GET", `/servers/${serverId}/port_bits`);
+        });
+    }
+    getServerPortUpkts(serverId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request("GET", `/servers/${serverId}/port_upkts`);
+        });
+    }
+    listReinstallDistros() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request("GET", "/reinstall/distro");
+        });
+    }
+    listReinstallOs(distroId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request("GET", `/reinstall/distro/${distroId}`);
+        });
+    }
+    reinstallServer(serverId, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.requestRaw("POST", `/servers/${serverId}/reinstall`, { body: params });
+            const meta = res;
+            return { message: meta.message, reboot: meta.reboot, root_passwd: meta.root_passwd };
+        });
+    }
+    updateServerReverse(serverId, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.requestWithMeta("PUT", `/servers/${serverId}/reverse`, { body: params });
+        });
+    }
+    listServerIsos(serverId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request("GET", `/servers/${serverId}/isos`);
+        });
+    }
+    mountServerIso(serverId, isoId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.requestWithMeta("POST", `/servers/${serverId}/isos`, { body: { iso_id: isoId } });
+        });
+    }
+    listServerUpgrades(serverId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request("GET", `/servers/${serverId}/upgrade`);
+        });
+    }
+    upgradeServer(serverId, pkgId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.requestWithMeta("POST", `/servers/${serverId}/upgrade`, { body: { pkg_id: pkgId } });
+        });
+    }
+    orderServerIpv4(serverId, ipType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.requestWithMeta("POST", `/servers/${serverId}/ipv4`, { body: { ip_type: ipType } });
+        });
+    }
+    getAccount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.requestRaw("GET", "/my/account");
+            const _a = res, { success: _s } = _a, account = __rest(_a, ["success"]);
+            return account;
+        });
+    }
+    listInvoices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const res = yield this.requestRaw("GET", "/my/invoices");
+            return (_a = res.invoices) !== null && _a !== void 0 ? _a : [];
+        });
+    }
+}
+exports.GigahostClient = GigahostClient;