statcon 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Logan Devine
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,45 @@
+# statcon
+
+The Status Configurator - a declarative configuration generator for Gatus config.yaml
+
+## Usage
+
+Statcon is packaged as a module on npm, and can be used in your own projects to generate Gatus configuration files.
+
+Configure a JS or TS project, install statcon, and then create a file like `statcon.conf.ts` with your desired configuration.
+
+See the [`statcon.conf.ts`](https://github.com/thetayloredman/statcon/blob/main/statcon.conf.ts) file for an example of Statcon's declarative, functional configuration style.
+
+## Output
+
+The `sc.generate()` function will return a JS object which you can then JSON.stringify and write to a file.
+
+Valid JSON is valid YAML, so you can write the output to the `config.yaml` file and it will be usable by Gatus.
+
+## Code Splitting
+
+If your configuration gets quite long and you want to split it into multiple files, you can export them as plugins and import them into your main configuration file, then `.use`ing them in the main configuration.
+
+For example, you could have a `plugins/` directory with files like `plugins/database.ts` and `plugins/api.ts`, each exporting a function that takes a Statcon instance and returns a plugin object.
+
+Then in your main `statcon.conf.ts`, you can import those plugins and use them:
+
+```ts
+import { Statcon } from "statcon";
+import databasePlugin from "./plugins/database";
+import apiPlugin from "./plugins/api";
+
+const config = sc.generate((config) =>
+    config.use(databasePlugin).use(apiPlugin)
+);
+```
+
+This allows you to keep your configuration organized and modular, especially as it grows in size and complexity.
+
+## Contributing
+
+Contributions to Statcon are welcome! If you have an idea for a new feature, or want to help improve the codebase, please open an issue or submit a pull request.
+
+## License
+
+Statcon is licensed under the MIT License. See the [LICENSE](./LICENSE) file for more information.

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import * as structures from "./structures/index.js";
+export * from "./structures/index.js";
+export declare function generate(cb: (config: structures.Configuration) => structures.Configuration): Record<string, unknown>;

package/dist/index.js

@@ -0,0 +1,36 @@
+import * as structures from "./structures/index.js";
+export * from "./structures/index.js";
+/**
+ * Converts a camelCase string to kebab-case
+ */
+function toKebabCase(str) {
+    return str.replace(/[A-Z]/g, (letter, offset) => {
+        return offset === 0 ? letter.toLowerCase() : `-${letter.toLowerCase()}`;
+    });
+}
+/**
+ * Recursively converts all object property names from camelCase to kebab-case
+ */
+function convertKeysToKebabCase(obj) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item) => convertKeysToKebabCase(item));
+    }
+    if (typeof obj === "object" && obj.constructor === Object) {
+        const newObj = {};
+        for (const key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                const kebabKey = toKebabCase(key);
+                newObj[kebabKey] = convertKeysToKebabCase(obj[key]);
+            }
+        }
+        return newObj;
+    }
+    return obj;
+}
+export function generate(cb) {
+    const serialized = cb(new structures.Configuration({})).serialize();
+    return convertKeysToKebabCase(serialized);
+}

package/dist/serializeCasing.d.ts

@@ -0,0 +1,10 @@
+type camelToKebabCase<S extends string> = S extends `${infer First}${infer Rest}` ? `${Lowercase<First>}${camelToKebabCaseHelper<Rest>}` : S;
+declare function camelToKebabCase<S extends string>(str: S): S;
+type camelToKebabCaseHelper<S extends string> = S extends `${infer First}${infer Rest}` ? First extends Uppercase<First> ? `-${Lowercase<First>}${camelToKebabCaseHelper<Rest>}` : `${First}${camelToKebabCaseHelper<Rest>}` : S;
+export type serializeCasing<T> = {
+    [K in keyof T as camelToKebabCase<string & K>]: T[K] extends object ? serializeCasing<T[K]> : T[K];
+} & unknown;
+export declare function serializeCasing<T extends {
+    [key: string]: any;
+}>(obj: T): serializeCasing<T>;
+export {};

package/dist/serializeCasing.js

@@ -0,0 +1,17 @@
+function camelToKebabCase(str) {
+    return str.replace(/([A-Z])/g, (match) => `-${match.toLowerCase()}`);
+}
+export function serializeCasing(obj) {
+    const result = {};
+    for (const key in obj) {
+        if (obj.hasOwnProperty(key)) {
+            const kebabKey = camelToKebabCase(key);
+            const value = obj[key];
+            result[kebabKey] =
+                typeof value === "object" && value !== null
+                    ? serializeCasing(value)
+                    : value;
+        }
+    }
+    return result;
+}

package/dist/structures/Alerting.d.ts

@@ -0,0 +1,26 @@
+import { Base, Serialize } from "./Base.js";
+export type AlertingConfiguration = {
+    type?: string;
+    enabled?: boolean;
+    failureThreshold?: number;
+    successThreshold?: number;
+    minimumReminderInterval?: number;
+    sendOnResolved?: boolean;
+    description?: string;
+    [additional: string]: any;
+    providerOverride?: Partial<AlertingConfiguration>;
+};
+export declare class Alerting extends Base implements Serialize {
+    data: AlertingConfiguration;
+    constructor(data: AlertingConfiguration);
+    type(type: string): this;
+    enabled(enabled: boolean): this;
+    failureThreshold(threshold: number): this;
+    successThreshold(threshold: number): this;
+    minimumReminderInterval(interval: number): this;
+    sendOnResolved(send: boolean): this;
+    description(description: string): this;
+    set(key: string, value: any): this;
+    providerOverride(override: Partial<AlertingConfiguration>): this;
+    serialize(): Record<string, any>;
+}

package/dist/structures/Alerting.js

@@ -0,0 +1,47 @@
+import { Base } from "./Base.js";
+export class Alerting extends Base {
+    data;
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+    type(type) {
+        this.data.type = type;
+        return this;
+    }
+    enabled(enabled) {
+        this.data.enabled = enabled;
+        return this;
+    }
+    failureThreshold(threshold) {
+        this.data.failureThreshold = threshold;
+        return this;
+    }
+    successThreshold(threshold) {
+        this.data.successThreshold = threshold;
+        return this;
+    }
+    minimumReminderInterval(interval) {
+        this.data.minimumReminderInterval = interval;
+        return this;
+    }
+    sendOnResolved(send) {
+        this.data.sendOnResolved = send;
+        return this;
+    }
+    description(description) {
+        this.data.description = description;
+        return this;
+    }
+    set(key, value) {
+        this.data[key] = value;
+        return this;
+    }
+    providerOverride(override) {
+        this.data.providerOverride = override;
+        return this;
+    }
+    serialize() {
+        return this.data;
+    }
+}

package/dist/structures/Announcement.d.ts

@@ -0,0 +1,15 @@
+import { Base, Serialize } from "./Base.js";
+export type AnnouncementConfiguration = {
+    timestamp?: number;
+    type?: "outage" | "warning" | "information" | "operational" | "none";
+    message?: string;
+    archived?: boolean;
+};
+export declare class Announcement extends Base implements Serialize {
+    data: AnnouncementConfiguration;
+    constructor(data: AnnouncementConfiguration);
+    message(message: string): this;
+    type(type: AnnouncementConfiguration["type"]): this;
+    archived(archived: boolean): this;
+    serialize(): Record<string, any>;
+}

package/dist/structures/Announcement.js

@@ -0,0 +1,23 @@
+import { Base } from "./Base.js";
+export class Announcement extends Base {
+    data;
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+    message(message) {
+        this.data.message = message;
+        return this;
+    }
+    type(type) {
+        this.data.type = type;
+        return this;
+    }
+    archived(archived) {
+        this.data.archived = archived;
+        return this;
+    }
+    serialize() {
+        return this.data;
+    }
+}

package/dist/structures/Base.d.ts

@@ -0,0 +1,6 @@
+export declare class Base {
+    use(cb: (thing: this) => this): this;
+}
+export interface Serialize {
+    serialize(): Record<string, any>;
+}

package/dist/structures/Base.js

@@ -0,0 +1,5 @@
+export class Base {
+    use(cb) {
+        return cb(this);
+    }
+}

package/dist/structures/Client.d.ts

@@ -0,0 +1,57 @@
+import { Base, Serialize } from "./Base.js";
+export type ClientConfiguration = {
+    insecure?: boolean;
+    ignoreRedirect?: boolean;
+    timeout?: string;
+    dnsResolver?: string;
+    oauth2?: {
+        tokenUrl?: string;
+        clientId?: string;
+        clientSecret?: string;
+        scopes?: string[];
+    };
+    proxyUrl?: string;
+    identityAwareProxy?: {
+        audience: string;
+    };
+    tls?: {
+        certificateFile?: string;
+        privateKeyFile?: string;
+        renegotiation?: "never" | "once" | "freely";
+    };
+    network?: "ip" | "ip4" | "ip6";
+    tunnel?: string;
+};
+export declare class OAuth2 extends Base implements Serialize {
+    data: NonNullable<ClientConfiguration["oauth2"]>;
+    constructor(data: NonNullable<ClientConfiguration["oauth2"]>);
+    tokenUrl(url: string): this;
+    clientId(id: string): this;
+    clientSecret(secret: string): this;
+    scopes(scopes: string[]): this;
+    serialize(): Record<string, any>;
+}
+export declare class Tls extends Base implements Serialize {
+    data: NonNullable<ClientConfiguration["tls"]>;
+    constructor(data: NonNullable<ClientConfiguration["tls"]>);
+    certificateFile(path: string): this;
+    privateKeyFile(path: string): this;
+    renegotiation(mode: NonNullable<ClientConfiguration["tls"]>["renegotiation"]): this;
+    serialize(): Record<string, any>;
+}
+export declare class Client extends Base implements Serialize {
+    data: ClientConfiguration;
+    constructor(data: ClientConfiguration);
+    insecure(insecure: boolean): this;
+    ignoreRedirect(ignore: boolean): this;
+    timeout(timeout: string): this;
+    dnsResolver(resolver: string): this;
+    proxyUrl(url: string): this;
+    identityAwareProxy(audience: string): this;
+    network(network: ClientConfiguration["network"]): this;
+    tunnel(tunnel: string): this;
+    oauth2(base: NonNullable<ClientConfiguration["oauth2"]>, cb: (oauth2: OAuth2) => OAuth2): this;
+    oauth2(cb: (oauth2: OAuth2) => OAuth2): this;
+    tls(baseOrCb: NonNullable<ClientConfiguration["tls"]> | ((tls: Tls) => Tls), cb?: (tls: Tls) => Tls): this;
+    serialize(): Record<string, any>;
+}

package/dist/structures/Client.js

@@ -0,0 +1,126 @@
+import { Base } from "./Base.js";
+export class OAuth2 extends Base {
+    data;
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+    tokenUrl(url) {
+        this.data.tokenUrl = url;
+        return this;
+    }
+    clientId(id) {
+        this.data.clientId = id;
+        return this;
+    }
+    clientSecret(secret) {
+        this.data.clientSecret = secret;
+        return this;
+    }
+    scopes(scopes) {
+        this.data.scopes = scopes;
+        return this;
+    }
+    serialize() {
+        return this.data;
+    }
+}
+export class Tls extends Base {
+    data;
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+    certificateFile(path) {
+        this.data.certificateFile = path;
+        return this;
+    }
+    privateKeyFile(path) {
+        this.data.privateKeyFile = path;
+        return this;
+    }
+    renegotiation(mode) {
+        this.data.renegotiation = mode;
+        return this;
+    }
+    serialize() {
+        return this.data;
+    }
+}
+export class Client extends Base {
+    data;
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+    insecure(insecure) {
+        this.data.insecure = insecure;
+        return this;
+    }
+    ignoreRedirect(ignore) {
+        this.data.ignoreRedirect = ignore;
+        return this;
+    }
+    timeout(timeout) {
+        this.data.timeout = timeout;
+        return this;
+    }
+    dnsResolver(resolver) {
+        this.data.dnsResolver = resolver;
+        return this;
+    }
+    proxyUrl(url) {
+        this.data.proxyUrl = url;
+        return this;
+    }
+    identityAwareProxy(audience) {
+        if (!this.data.identityAwareProxy) {
+            this.data.identityAwareProxy = { audience };
+        }
+        else {
+            this.data.identityAwareProxy.audience = audience;
+        }
+        return this;
+    }
+    network(network) {
+        this.data.network = network;
+        return this;
+    }
+    tunnel(tunnel) {
+        this.data.tunnel = tunnel;
+        return this;
+    }
+    oauth2(baseOrCb, cb) {
+        let oauth2Instance;
+        if (typeof baseOrCb === "function") {
+            oauth2Instance = new OAuth2({});
+            oauth2Instance = baseOrCb(oauth2Instance);
+        }
+        else {
+            oauth2Instance = new OAuth2(baseOrCb);
+            if (cb) {
+                oauth2Instance = cb(oauth2Instance);
+            }
+        }
+        this.data.oauth2 = oauth2Instance.data;
+        return this;
+    }
+    tls(baseOrCb, cb) {
+        let tlsInstance;
+        if (typeof baseOrCb === "function") {
+            tlsInstance = new Tls({});
+            tlsInstance = baseOrCb(tlsInstance);
+        }
+        else {
+            tlsInstance = new Tls(baseOrCb);
+            if (cb) {
+                tlsInstance = cb(tlsInstance);
+            }
+        }
+        this.data.tls = tlsInstance.data;
+        return this;
+    }
+    serialize() {
+        return this.data;
+    }
+}

package/dist/structures/Configuration.d.ts

@@ -0,0 +1,54 @@
+import { Alerting, AlertingConfiguration } from "./Alerting.js";
+import { Announcement, AnnouncementConfiguration } from "./Announcement.js";
+import { Base, Serialize } from "./Base.js";
+import { Endpoint, EndpointConfiguration } from "./Endpoint.js";
+import { ExternalEndpoint, ExternalEndpointConfiguration } from "./ExternalEndpoint.js";
+import { Maintenance, MaintenanceConfiguration } from "./Maintenance.js";
+import { Security, SecurityConfiguration } from "./Security.js";
+import { Storage, StorageConfiguration } from "./Storage.js";
+import { Tunnel, TunnelingConfiguration } from "./Tunnel.js";
+import { UI, UIConfiguration } from "./UI.js";
+import { Web, WebConfiguration } from "./Web.js";
+export type ConfigurationConfiguration = {
+    metrics?: boolean;
+    storage?: Storage;
+    alerting?: Alerting[];
+    announcements?: Announcement[];
+    endpoints?: Endpoint[];
+    externalEndpoints?: ExternalEndpoint[];
+    security?: Security;
+    concurrency?: number;
+    skipInvalidConfigUpdate?: boolean;
+    web?: Web;
+    ui?: UI;
+    maintenance?: Maintenance[];
+    tunneling?: Record<string, Tunnel>;
+};
+export declare class Configuration extends Base implements Serialize {
+    data: ConfigurationConfiguration;
+    constructor(data: ConfigurationConfiguration);
+    metrics(enabled: boolean): this;
+    concurrency(concurrency: number): this;
+    skipInvalidConfigUpdate(skip: boolean): this;
+    storage(base: StorageConfiguration, storage?: (storage: Storage) => Storage): this;
+    storage(storage: (storage: Storage) => Storage): this;
+    web(base: WebConfiguration, web?: (web: Web) => Web): this;
+    web(web: (web: Web) => Web): this;
+    ui(base: UIConfiguration, ui?: (ui: UI) => UI): this;
+    ui(ui: (ui: UI) => UI): this;
+    security(base: SecurityConfiguration, security?: (security: Security) => Security): this;
+    security(security: (security: Security) => Security): this;
+    alert(base: AlertingConfiguration, alert?: (alert: Alerting) => Alerting): this;
+    alert(alert: (alert: Alerting) => Alerting): this;
+    announcement(base: AnnouncementConfiguration, announcement?: (announcement: Announcement) => Announcement): this;
+    announcement(announcement: (announcement: Announcement) => Announcement): this;
+    maintenance(base: MaintenanceConfiguration, maintenance?: (maintenance: Maintenance) => Maintenance): this;
+    maintenance(maintenance: (maintenance: Maintenance) => Maintenance): this;
+    endpoint(base: EndpointConfiguration, endpoint?: (endpoint: Endpoint) => Endpoint): this;
+    endpoint(endpoint: (endpoint: Endpoint) => Endpoint): this;
+    externalEndpoint(base: ExternalEndpointConfiguration, endpoint?: (endpoint: ExternalEndpoint) => ExternalEndpoint): this;
+    externalEndpoint(endpoint: (endpoint: ExternalEndpoint) => ExternalEndpoint): this;
+    tunnel(name: string, base: TunnelingConfiguration, tunnel?: (tunnel: Tunnel) => Tunnel): this;
+    tunnel(name: string, tunnel: (tunnel: Tunnel) => Tunnel): this;
+    serialize(): Record<string, any>;
+}