statcon 0.1.0

package/dist/structures/Configuration.js

@@ -0,0 +1,215 @@
+import { Alerting } from "./Alerting.js";
+import { Announcement } from "./Announcement.js";
+import { Base } from "./Base.js";
+import { Endpoint } from "./Endpoint.js";
+import { ExternalEndpoint, } from "./ExternalEndpoint.js";
+import { Maintenance } from "./Maintenance.js";
+import { Security } from "./Security.js";
+import { Storage } from "./Storage.js";
+import { Tunnel } from "./Tunnel.js";
+import { UI } from "./UI.js";
+import { Web } from "./Web.js";
+export class Configuration extends Base {
+    data;
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+    metrics(enabled) {
+        this.data.metrics = enabled;
+        return this;
+    }
+    concurrency(concurrency) {
+        this.data.concurrency = concurrency;
+        return this;
+    }
+    skipInvalidConfigUpdate(skip) {
+        this.data.skipInvalidConfigUpdate = skip;
+        return this;
+    }
+    storage(baseOrStorage, storage) {
+        let storageInstance;
+        if (typeof baseOrStorage === "function") {
+            storageInstance = baseOrStorage(new Storage({}));
+        }
+        else {
+            storageInstance = new Storage(baseOrStorage);
+            if (storage)
+                storageInstance = storage(storageInstance);
+        }
+        this.data.storage = storageInstance;
+        return this;
+    }
+    web(baseOrWeb, web) {
+        let webInstance;
+        if (typeof baseOrWeb === "function") {
+            webInstance = baseOrWeb(new Web({}));
+        }
+        else {
+            webInstance = new Web(baseOrWeb);
+            if (web)
+                webInstance = web(webInstance);
+        }
+        this.data.web = webInstance;
+        return this;
+    }
+    ui(baseOrUi, ui) {
+        let uiInstance;
+        if (typeof baseOrUi === "function") {
+            uiInstance = baseOrUi(new UI({}));
+        }
+        else {
+            uiInstance = new UI(baseOrUi);
+            if (ui)
+                uiInstance = ui(uiInstance);
+        }
+        this.data.ui = uiInstance;
+        return this;
+    }
+    security(baseOrSecurity, security) {
+        let securityInstance;
+        if (typeof baseOrSecurity === "function") {
+            securityInstance = baseOrSecurity(new Security({}));
+        }
+        else {
+            securityInstance = new Security(baseOrSecurity);
+            if (security)
+                securityInstance = security(securityInstance);
+        }
+        this.data.security = securityInstance;
+        return this;
+    }
+    alert(baseOrAlert, alert) {
+        let alertInstance;
+        if (typeof baseOrAlert === "function") {
+            alertInstance = baseOrAlert(new Alerting({}));
+        }
+        else {
+            alertInstance = new Alerting(baseOrAlert);
+            if (alert)
+                alertInstance = alert(alertInstance);
+        }
+        if (!this.data.alerting) {
+            this.data.alerting = [];
+        }
+        this.data.alerting.push(alertInstance);
+        return this;
+    }
+    announcement(baseOrAnnouncement, announcement) {
+        let announcementInstance;
+        if (typeof baseOrAnnouncement === "function") {
+            announcementInstance = baseOrAnnouncement(new Announcement({}));
+        }
+        else {
+            announcementInstance = new Announcement(baseOrAnnouncement);
+            if (announcement)
+                announcementInstance = announcement(announcementInstance);
+        }
+        if (!this.data.announcements) {
+            this.data.announcements = [];
+        }
+        this.data.announcements.push(announcementInstance);
+        return this;
+    }
+    maintenance(baseOrMaintenance, maintenance) {
+        let maintenanceInstance;
+        if (typeof baseOrMaintenance === "function") {
+            maintenanceInstance = baseOrMaintenance(new Maintenance({}));
+        }
+        else {
+            maintenanceInstance = new Maintenance(baseOrMaintenance);
+            if (maintenance)
+                maintenanceInstance = maintenance(maintenanceInstance);
+        }
+        if (!this.data.maintenance) {
+            this.data.maintenance = [];
+        }
+        this.data.maintenance.push(maintenanceInstance);
+        return this;
+    }
+    endpoint(baseOrEndpoint, endpoint) {
+        let endpointInstance;
+        if (typeof baseOrEndpoint === "function") {
+            endpointInstance = baseOrEndpoint(new Endpoint({}));
+        }
+        else {
+            endpointInstance = new Endpoint(baseOrEndpoint);
+            if (endpoint)
+                endpointInstance = endpoint(endpointInstance);
+        }
+        if (!this.data.endpoints) {
+            this.data.endpoints = [];
+        }
+        this.data.endpoints.push(endpointInstance);
+        return this;
+    }
+    externalEndpoint(baseOrEndpoint, endpoint) {
+        let endpointInstance;
+        if (typeof baseOrEndpoint === "function") {
+            endpointInstance = baseOrEndpoint(new ExternalEndpoint({}));
+        }
+        else {
+            endpointInstance = new ExternalEndpoint(baseOrEndpoint);
+            if (endpoint)
+                endpointInstance = endpoint(endpointInstance);
+        }
+        if (!this.data.externalEndpoints) {
+            this.data.externalEndpoints = [];
+        }
+        this.data.externalEndpoints.push(endpointInstance);
+        return this;
+    }
+    tunnel(name, baseOrTunnel, tunnel) {
+        let tunnelInstance;
+        if (typeof baseOrTunnel === "function") {
+            tunnelInstance = baseOrTunnel(new Tunnel({}));
+        }
+        else {
+            tunnelInstance = new Tunnel(baseOrTunnel);
+            if (tunnel)
+                tunnelInstance = tunnel(tunnelInstance);
+        }
+        if (!this.data.tunneling) {
+            this.data.tunneling = {};
+        }
+        this.data.tunneling[name] = tunnelInstance;
+        return this;
+    }
+    serialize() {
+        let output = { ...this.data };
+        if (this.data.alerting) {
+            output.alerting = this.data.alerting.map((alert) => alert.serialize());
+        }
+        if (this.data.announcements) {
+            output.announcements = this.data.announcements.map((announcement) => announcement.serialize());
+        }
+        if (this.data.endpoints) {
+            output.endpoints = this.data.endpoints.map((endpoint) => endpoint.serialize());
+        }
+        if (this.data.externalEndpoints) {
+            output.externalEndpoints = Object.fromEntries(Object.entries(this.data.externalEndpoints).map(([key, endpoint]) => [key, endpoint.serialize()]));
+        }
+        if (this.data.maintenance) {
+            output.maintenance = this.data.maintenance.map((maintenance) => maintenance.serialize());
+        }
+        if (this.data.tunneling) {
+            output.tunneling = Object.fromEntries(Object.entries(this.data.tunneling).map(([key, tunnel]) => [
+                key,
+                tunnel.serialize(),
+            ]));
+        }
+        if (this.data.security) {
+            output.security = this.data.security.serialize();
+        }
+        if (this.data.storage) {
+            output.storage = this.data.storage.serialize();
+        }
+        if (this.data.web) {
+            output.web = this.data.web.serialize();
+        }
+        if (this.data.ui) {
+            output.ui = this.data.ui.serialize();
+        }
+        return output;
+    }
+}

package/dist/structures/Endpoint.d.ts

@@ -0,0 +1,84 @@
+import { Alerting, AlertingConfiguration } from "./Alerting.js";
+import { Base, Serialize } from "./Base.js";
+import { Client, ClientConfiguration } from "./Client.js";
+import { Maintenance, MaintenanceConfiguration } from "./Maintenance.js";
+export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
+export type DnsRecordType = "A" | "AAAA" | "CNAME" | "MX" | "TXT" | "SRV" | "NS" | "PTR";
+export type Condition = string;
+export type EndpointConfiguration = {
+    enabled?: boolean;
+    name?: string;
+    group?: string;
+    url?: string;
+    method?: HttpMethod;
+    conditions?: Condition[];
+    interval?: string;
+    graphql?: boolean;
+    /**
+    You may use the following placeholders in the body (endpoints[].body):
+    [ENDPOINT_NAME] (resolved from endpoints[].name)
+    [ENDPOINT_GROUP] (resolved from endpoints[].group)
+    [ENDPOINT_URL] (resolved from endpoints[].url)
+    [LOCAL_ADDRESS] (resolves to the local IP and port like 192.0.2.1:25 or [2001:db8::1]:80)
+    [RANDOM_STRING_N] (resolves to a random string of numbers and letters of length N (max: 8192))
+    */
+    body?: string;
+    headers?: Record<string, string>;
+    dns?: {
+        queryName: string;
+        queryType: DnsRecordType;
+    };
+    ssh?: {
+        username: string;
+        password: string;
+    };
+    alerts?: Alerting[];
+    maintenanceWindows?: Maintenance[];
+    client?: Client;
+    ui?: {
+        hideConditions?: boolean;
+        hideHostname?: boolean;
+        hidePort?: boolean;
+        hideUrl?: boolean;
+        hideErrors?: boolean;
+        dontResolveFailedConditions?: boolean;
+        badge?: {
+            responseTime?: number[];
+        };
+    };
+    extraLabels?: Record<string, string>;
+};
+export declare class EndpointUI extends Base implements Serialize {
+    data: NonNullable<EndpointConfiguration["ui"]>;
+    constructor(data: NonNullable<EndpointConfiguration["ui"]>);
+    hideConditions(hide: boolean): this;
+    hideHostname(hide: boolean): this;
+    hidePort(hide: boolean): this;
+    hideUrl(hide: boolean): this;
+    hideErrors(hide: boolean): this;
+    dontResolveFailedConditions(dontResolve: boolean): this;
+    badgeResponseTime(thresholds: number[]): this;
+    serialize(): Record<string, any>;
+}
+export declare class Endpoint extends Base implements Serialize {
+    data: EndpointConfiguration;
+    constructor(data: EndpointConfiguration);
+    name(name: string): this;
+    enabled(enabled: boolean): this;
+    group(group: string): this;
+    url(url: string): this;
+    method(method: HttpMethod): this;
+    addCondition(condition: Condition): this;
+    interval(interval: string): this;
+    graphql(enabled: boolean): this;
+    body(body: string): this;
+    header(key: string, value: string): this;
+    dns(queryName: string, queryType: DnsRecordType): this;
+    ssh(username: string, password: string): this;
+    alert(base: AlertingConfiguration, cb?: (alert: Alerting) => Alerting): this;
+    maintenance(base: MaintenanceConfiguration, cb?: (maintenance: Maintenance) => Maintenance): this;
+    client(base: ClientConfiguration, cb?: (client: Client) => Client): this;
+    ui(base: NonNullable<EndpointConfiguration["ui"]>, cb?: (ui: EndpointUI) => EndpointUI): this;
+    extraLabel(key: string, value: string): this;
+    serialize(): Record<string, any>;
+}

package/dist/structures/Endpoint.js

@@ -0,0 +1,163 @@
+import { Alerting } from "./Alerting.js";
+import { Base } from "./Base.js";
+import { Client } from "./Client.js";
+import { Maintenance } from "./Maintenance.js";
+export class EndpointUI extends Base {
+    data;
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+    hideConditions(hide) {
+        this.data.hideConditions = hide;
+        return this;
+    }
+    hideHostname(hide) {
+        this.data.hideHostname = hide;
+        return this;
+    }
+    hidePort(hide) {
+        this.data.hidePort = hide;
+        return this;
+    }
+    hideUrl(hide) {
+        this.data.hideUrl = hide;
+        return this;
+    }
+    hideErrors(hide) {
+        this.data.hideErrors = hide;
+        return this;
+    }
+    dontResolveFailedConditions(dontResolve) {
+        this.data.dontResolveFailedConditions = dontResolve;
+        return this;
+    }
+    badgeResponseTime(thresholds) {
+        if (!this.data.badge) {
+            this.data.badge = {};
+        }
+        this.data.badge.responseTime = thresholds;
+        return this;
+    }
+    serialize() {
+        return this.data;
+    }
+}
+export class Endpoint extends Base {
+    data;
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+    name(name) {
+        this.data.name = name;
+        return this;
+    }
+    enabled(enabled) {
+        this.data.enabled = enabled;
+        return this;
+    }
+    group(group) {
+        this.data.group = group;
+        return this;
+    }
+    url(url) {
+        this.data.url = url;
+        return this;
+    }
+    method(method) {
+        this.data.method = method;
+        return this;
+    }
+    addCondition(condition) {
+        if (!this.data.conditions) {
+            this.data.conditions = [];
+        }
+        this.data.conditions.push(condition);
+        return this;
+    }
+    interval(interval) {
+        this.data.interval = interval;
+        return this;
+    }
+    graphql(enabled) {
+        this.data.graphql = enabled;
+        return this;
+    }
+    body(body) {
+        this.data.body = body;
+        return this;
+    }
+    header(key, value) {
+        if (!this.data.headers) {
+            this.data.headers = {};
+        }
+        this.data.headers[key] = value;
+        return this;
+    }
+    dns(queryName, queryType) {
+        this.data.dns = { queryName, queryType };
+        return this;
+    }
+    ssh(username, password) {
+        this.data.ssh = { username, password };
+        return this;
+    }
+    alert(base, cb) {
+        if (!this.data.alerts) {
+            this.data.alerts = [];
+        }
+        let alertInstance = new Alerting(base);
+        if (cb)
+            alertInstance = cb(alertInstance);
+        this.data.alerts.push(alertInstance);
+        return this;
+    }
+    maintenance(base, cb) {
+        if (!this.data.maintenanceWindows) {
+            this.data.maintenanceWindows = [];
+        }
+        let maintenanceInstance = new Maintenance(base);
+        if (cb)
+            maintenanceInstance = cb(maintenanceInstance);
+        this.data.maintenanceWindows.push(maintenanceInstance);
+        return this;
+    }
+    client(base, cb) {
+        let clientInstance = new Client(base);
+        if (cb)
+            clientInstance = cb(clientInstance);
+        this.data.client = clientInstance;
+        return this;
+    }
+    ui(base, cb) {
+        let uiInstance = new EndpointUI(base);
+        if (cb)
+            uiInstance = cb(uiInstance);
+        this.data.ui = uiInstance.data;
+        return this;
+    }
+    extraLabel(key, value) {
+        if (!this.data.extraLabels) {
+            this.data.extraLabels = {};
+        }
+        this.data.extraLabels[key] = value;
+        return this;
+    }
+    serialize() {
+        let output = { ...this.data };
+        if (this.data.alerts) {
+            output.alerts = this.data.alerts?.map((alert) => alert.serialize());
+        }
+        if (this.data.maintenanceWindows) {
+            output.maintenanceWindows = this.data.maintenanceWindows.map((m) => m.serialize());
+        }
+        if (this.data.client) {
+            output.client = this.data.client.serialize();
+        }
+        if (this.data.ui) {
+            output.ui = this.data.ui;
+        }
+        return output;
+    }
+}

package/dist/structures/ExternalEndpoint.d.ts

@@ -0,0 +1,22 @@
+import { Alerting, AlertingConfiguration } from "./Alerting.js";
+import { Base, Serialize } from "./Base.js";
+export type ExternalEndpointConfiguration = {
+    enabled?: boolean;
+    name?: string;
+    group?: string;
+    token?: string;
+    alerts?: Alerting[];
+    heartbeat?: {
+        interval?: string;
+    };
+};
+export declare class ExternalEndpoint extends Base implements Serialize {
+    data: ExternalEndpointConfiguration;
+    constructor(data: ExternalEndpointConfiguration);
+    enabled(enabled: boolean): this;
+    group(group: string): this;
+    token(token: string): this;
+    heartbeatInterval(interval: string): this;
+    alert(base: AlertingConfiguration, alert?: (alert: Alerting) => Alerting): this;
+    serialize(): Record<string, any>;
+}

package/dist/structures/ExternalEndpoint.js

@@ -0,0 +1,44 @@
+import { Alerting } from "./Alerting.js";
+import { Base } from "./Base.js";
+export class ExternalEndpoint extends Base {
+    data;
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+    enabled(enabled) {
+        this.data.enabled = enabled;
+        return this;
+    }
+    group(group) {
+        this.data.group = group;
+        return this;
+    }
+    token(token) {
+        this.data.token = token;
+        return this;
+    }
+    heartbeatInterval(interval) {
+        if (!this.data.heartbeat) {
+            this.data.heartbeat = {};
+        }
+        this.data.heartbeat.interval = interval;
+        return this;
+    }
+    alert(base, alert) {
+        if (!this.data.alerts) {
+            this.data.alerts = [];
+        }
+        let alertInstance = new Alerting(base);
+        if (alert)
+            alertInstance = alert(alertInstance);
+        this.data.alerts.push(alertInstance);
+        return this;
+    }
+    serialize() {
+        return {
+            ...this.data,
+            alerts: this.data.alerts?.map((alert) => alert.serialize()),
+        };
+    }
+}

package/dist/structures/Maintenance.d.ts

@@ -0,0 +1,18 @@
+import { Base, Serialize } from "./Base.js";
+export type MaintenanceConfiguration = {
+    enabled?: boolean;
+    start?: string;
+    duration?: string;
+    timezone?: string;
+    every?: string[];
+};
+export declare class Maintenance extends Base implements Serialize {
+    data: MaintenanceConfiguration;
+    constructor(data: MaintenanceConfiguration);
+    enabled(enabled: boolean): this;
+    start(start: string): this;
+    duration(duration: string): this;
+    timezone(timezone: string): this;
+    every(every: string[]): this;
+    serialize(): Record<string, any>;
+}

package/dist/structures/Maintenance.js

@@ -0,0 +1,31 @@
+import { Base } from "./Base.js";
+export class Maintenance extends Base {
+    data;
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+    enabled(enabled) {
+        this.data.enabled = enabled;
+        return this;
+    }
+    start(start) {
+        this.data.start = start;
+        return this;
+    }
+    duration(duration) {
+        this.data.duration = duration;
+        return this;
+    }
+    timezone(timezone) {
+        this.data.timezone = timezone;
+        return this;
+    }
+    every(every) {
+        this.data.every = every;
+        return this;
+    }
+    serialize() {
+        return this.data;
+    }
+}

package/dist/structures/Security.d.ts

@@ -0,0 +1,44 @@
+import { Base, Serialize } from "./Base.js";
+export type SecurityConfiguration = {
+    basic?: {
+        username?: string;
+        passwordBcryptBase64?: string;
+    };
+    oidc?: {
+        issuerUrl?: string;
+        redirectUrl?: string;
+        clientId?: string;
+        clientSecret?: string;
+        scopes?: string[];
+        allowedSubjects?: string[];
+        sessionTtl?: string;
+    };
+};
+export declare class BasicSecurity extends Base implements Serialize {
+    data: NonNullable<SecurityConfiguration["basic"]>;
+    constructor(data: NonNullable<SecurityConfiguration["basic"]>);
+    username(username: string): this;
+    passwordBcryptBase64(password: string): this;
+    serialize(): Record<string, any>;
+}
+export declare class OidcSecurity extends Base implements Serialize {
+    data: NonNullable<SecurityConfiguration["oidc"]>;
+    constructor(data: NonNullable<SecurityConfiguration["oidc"]>);
+    issuerUrl(url: string): this;
+    redirectUrl(url: string): this;
+    clientId(id: string): this;
+    clientSecret(secret: string): this;
+    scopes(scopes: string[]): this;
+    allowedSubjects(subjects: string[]): this;
+    sessionTtl(ttl: string): this;
+    serialize(): Record<string, any>;
+}
+export declare class Security extends Base implements Serialize {
+    data: SecurityConfiguration;
+    constructor(data: SecurityConfiguration);
+    basic(base: NonNullable<SecurityConfiguration["basic"]>, cb: (basic: BasicSecurity) => BasicSecurity): this;
+    basic(cb: (basic: BasicSecurity) => BasicSecurity): this;
+    oidc(base: NonNullable<SecurityConfiguration["oidc"]>, cb: (oidc: OidcSecurity) => OidcSecurity): this;
+    oidc(cb: (oidc: OidcSecurity) => OidcSecurity): this;
+    serialize(): Record<string, any>;
+}