@drunk-pulumi/azure 0.0.19

package/KubeX/Tools/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const KubeCleanup_1 = require("./KubeCleanup");
+const ToolPod_1 = require("./ToolPod");
+const SqlPad_1 = require("./SqlPad");
+const OutlineVpn_1 = require("./OutlineVpn");
+const NoIp_1 = require("./NoIp");
+const AppHealthzMonitor_1 = require("./AppHealthzMonitor");
+const UptimeKuma_1 = require("./UptimeKuma");
+const OpenLDAP_1 = require("./OpenLDAP");
+const HelloWorld_1 = require("./HelloWorld");
+const Echo_App_1 = require("./Echo-App");
+exports.default = async ({ helloWorld, echo, enableKubeCleanup, toolPod, noIp, sqlPad, outlineVpn, openLdap, appHealthMonitor, uptimeKuma, namespace, ...others }) => {
+    if (helloWorld)
+        (0, HelloWorld_1.default)({ namespace, ...others, ...helloWorld });
+    if (echo)
+        (0, Echo_App_1.default)({ namespace, ...others, ...echo });
+    if (enableKubeCleanup)
+        (0, KubeCleanup_1.default)({ namespace, ...others });
+    if (toolPod)
+        (0, ToolPod_1.default)({ namespace, ...others, ...toolPod });
+    if (noIp)
+        (0, NoIp_1.default)({ namespace, ...others, ...noIp });
+    if (sqlPad)
+        await (0, SqlPad_1.default)({ namespace, ...others, ...sqlPad });
+    if (outlineVpn)
+        await (0, OutlineVpn_1.default)({ ...others, ...outlineVpn });
+    if (openLdap)
+        (0, OpenLDAP_1.default)({ ...others, ...openLdap });
+    if (appHealthMonitor)
+        (0, AppHealthzMonitor_1.default)({ namespace, ...others, ...appHealthMonitor });
+    if (uptimeKuma)
+        (0, UptimeKuma_1.default)({ namespace, ...others, ...uptimeKuma });
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvS3ViZVgvVG9vbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFFQSwrQ0FBd0M7QUFDeEMsdUNBQWtEO0FBQ2xELHFDQUErQztBQUMvQyw2Q0FBd0Q7QUFDeEQsaUNBQXlDO0FBQ3pDLDJEQUE4RTtBQUM5RSw2Q0FBMkQ7QUFDM0QseUNBQXFEO0FBQ3JELDZDQUFzQztBQUN0Qyx5Q0FBaUM7QUF5QmpDLGtCQUFlLEtBQUssRUFBRSxFQUNwQixVQUFVLEVBQ1YsSUFBSSxFQUVKLGlCQUFpQixFQUNqQixPQUFPLEVBQ1AsSUFBSSxFQUNKLE1BQU0sRUFDTixVQUFVLEVBQ1YsUUFBUSxFQUNSLGdCQUFnQixFQUNoQixVQUFVLEVBQ1YsU0FBUyxFQUNULEdBQUcsTUFBTSxFQUNILEVBQUUsRUFBRTtJQUNWLElBQUksVUFBVTtRQUFFLElBQUEsb0JBQVUsRUFBQyxFQUFFLFNBQVMsRUFBRSxHQUFHLE1BQU0sRUFBRSxHQUFHLFVBQVUsRUFBRSxDQUFDLENBQUM7SUFDcEUsSUFBSSxJQUFJO1FBQUUsSUFBQSxrQkFBTyxFQUFDLEVBQUUsU0FBUyxFQUFFLEdBQUcsTUFBTSxFQUFFLEdBQUcsSUFBSSxFQUFFLENBQUMsQ0FBQztJQUVyRCxJQUFJLGlCQUFpQjtRQUFFLElBQUEscUJBQVcsRUFBQyxFQUFFLFNBQVMsRUFBRSxHQUFHLE1BQU0sRUFBRSxDQUFDLENBQUM7SUFDN0QsSUFBSSxPQUFPO1FBQUUsSUFBQSxpQkFBTyxFQUFDLEVBQUUsU0FBUyxFQUFFLEdBQUcsTUFBTSxFQUFFLEdBQUcsT0FBTyxFQUFFLENBQUMsQ0FBQztJQUMzRCxJQUFJLElBQUk7UUFBRSxJQUFBLGNBQUksRUFBQyxFQUFFLFNBQVMsRUFBRSxHQUFHLE1BQU0sRUFBRSxHQUFHLElBQUksRUFBRSxDQUFDLENBQUM7SUFDbEQsSUFBSSxNQUFNO1FBQUUsTUFBTSxJQUFBLGdCQUFNLEVBQUMsRUFBRSxTQUFTLEVBQUUsR0FBRyxNQUFNLEVBQUUsR0FBRyxNQUFNLEVBQUUsQ0FBQyxDQUFDO0lBQzlELElBQUksVUFBVTtRQUFFLE1BQU0sSUFBQSxvQkFBVSxFQUFDLEVBQUUsR0FBRyxNQUFNLEVBQUUsR0FBRyxVQUFVLEVBQUUsQ0FBQyxDQUFDO0lBQy9ELElBQUksUUFBUTtRQUFFLElBQUEsa0JBQVEsRUFBQyxFQUFFLEdBQUcsTUFBTSxFQUFFLEdBQUcsUUFBUSxFQUFFLENBQUMsQ0FBQztJQUNuRCxJQUFJLGdCQUFnQjtRQUNsQixJQUFBLDJCQUFnQixFQUFDLEVBQUUsU0FBUyxFQUFFLEdBQUcsTUFBTSxFQUFFLEdBQUcsZ0JBQWdCLEVBQUUsQ0FBQyxDQUFDO0lBQ2xFLElBQUksVUFBVTtRQUFFLElBQUEsb0JBQVUsRUFBQyxFQUFFLFNBQVMsRUFBRSxHQUFHLE1BQU0sRUFBRSxHQUFHLFVBQVUsRUFBRSxDQUFDLENBQUM7QUFDdEUsQ0FBQyxDQUFDIn0=

package/KubeX/VairableResolvers/index.d.ts

@@ -0,0 +1,15 @@
+import { KeyVaultInfo } from '../../types';
+import { Input, Output } from '@pulumi/pulumi';
+interface Props {
+    config: {
+        [key: string]: string | Input<string>;
+    };
+    vaultInfo: KeyVaultInfo;
+}
+/** Resolve the secrets from KeyVault*/
+export declare const secretOutput: (vaultInfo: KeyVaultInfo, ...names: string[]) => Output<Array<string | undefined>>;
+declare const resolver: ({ config, vaultInfo }: Props) => Promise<{
+    configMap: Record<string, Input<string>>;
+    secrets: Record<string, Input<string>>;
+}>;
+export default resolver;

package/KubeX/VairableResolvers/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secretOutput = void 0;
+const Helper_1 = require("../../KeyVault/Helper");
+const pulumi_1 = require("@pulumi/pulumi");
+/** Resolve the secrets from KeyVault*/
+const secretOutput = (vaultInfo, ...names) => (0, pulumi_1.output)(Promise.all(names.map(async (n) => {
+    const rs = await (0, Helper_1.getSecret)({ name: n, vaultInfo });
+    return rs?.value ?? n;
+})));
+exports.secretOutput = secretOutput;
+const resolver = async ({ config, vaultInfo }) => {
+    const secrets = {};
+    const configMap = {};
+    const notfound = new Array();
+    const rs = await Promise.all(Object.keys(config)
+        .sort()
+        .map(async (k) => {
+        let value = config[k];
+        let secret = false;
+        if (typeof value === 'string' &&
+            value.startsWith('$(') &&
+            value.endsWith(')')) {
+            secret = true;
+            const key = value.replace('$(', '').replace(')', '').trim();
+            value = (await (0, Helper_1.getSecret)({ name: key, vaultInfo }))?.value;
+        }
+        if (value)
+            return { key: k, value, secret };
+        else {
+            notfound.push(k);
+            return undefined;
+        }
+    }));
+    if (notfound.length > 0) {
+        throw new Error(`The variable "${notfound.join('\n')}" is invalid or not from: ${vaultInfo.name}`);
+    }
+    rs.forEach((v) => {
+        if (!v)
+            return;
+        if (v.secret)
+            secrets[v.key] = v.value;
+        else
+            configMap[v.key] = v.value;
+    });
+    return { configMap, secrets };
+};
+exports.default = resolver;
+//# sourceMappingURL=data:application/json;base64,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

package/KubeX/kx/index.d.ts

@@ -0,0 +1,114 @@
+import * as k8s from '@pulumi/kubernetes';
+import * as pulumi from '@pulumi/pulumi';
+export declare namespace types {
+    type EnvMap = Record<string, pulumi.Input<string | k8s.types.input.core.v1.EnvVarSource>>;
+    type PortMap = Record<string, pulumi.Input<number>>;
+    enum ServiceType {
+        ClusterIP = "ClusterIP",
+        LoadBalancer = "LoadBalancer"
+    }
+    type VolumeMount = {
+        volume: pulumi.Input<k8s.types.input.core.v1.Volume>;
+        destPath: pulumi.Input<string>;
+        srcPath?: pulumi.Input<string>;
+    };
+    type Container = Omit<k8s.types.input.core.v1.Container, 'env' | 'name' | 'ports' | 'volumeMounts'> & {
+        env?: pulumi.Input<pulumi.Input<k8s.types.input.core.v1.EnvVar>[] | EnvMap>;
+        name?: pulumi.Input<string>;
+        ports?: pulumi.Input<pulumi.Input<k8s.types.input.core.v1.ContainerPort>[] | PortMap>;
+        volumeMounts?: pulumi.Input<pulumi.Input<k8s.types.input.core.v1.VolumeMount | VolumeMount>[]>;
+    };
+    type PodSpec = Omit<k8s.types.input.core.v1.PodSpec, 'containers' | 'initContainers'> & {
+        containers: pulumi.Input<pulumi.Input<Container>[]>;
+        initContainers?: pulumi.Input<pulumi.Input<Container>[]>;
+    };
+    type Pod = Omit<k8s.types.input.core.v1.Pod, 'spec'> & {
+        spec: pulumi.Input<PodSpec | PodBuilder>;
+    };
+    type DeploymentSpec = Omit<k8s.types.input.apps.v1.DeploymentSpec, 'template'> & {
+        template: pulumi.Input<Pod>;
+    };
+    type Deployment = Omit<k8s.types.input.apps.v1.Deployment, 'spec'> & {
+        spec: pulumi.Input<DeploymentSpec | k8s.types.input.apps.v1.DeploymentSpec>;
+    };
+    type ServiceSpec = Omit<k8s.types.input.core.v1.ServiceSpec, 'ports' | 'type'> & {
+        name?: string;
+        ports?: pulumi.Input<pulumi.Input<k8s.types.input.core.v1.ServicePort>[] | PortMap>;
+        type?: pulumi.Input<ServiceType | string>;
+    };
+    type Service = Omit<k8s.types.input.core.v1.Service, 'spec'> & {
+        spec: pulumi.Input<ServiceSpec>;
+    };
+    type StatefulSetSpec = Omit<k8s.types.input.apps.v1.StatefulSetSpec, 'template'> & {
+        template: pulumi.Input<Pod>;
+    };
+    type StatefulSet = Omit<k8s.types.input.apps.v1.StatefulSet, 'spec'> & {
+        spec: pulumi.Input<StatefulSetSpec | k8s.types.input.apps.v1.StatefulSetSpec>;
+    };
+    type JobSpec = Omit<k8s.types.input.batch.v1.JobSpec, 'template'> & {
+        template: pulumi.Input<Pod>;
+    };
+    type Job = Omit<k8s.types.input.batch.v1.Job, 'spec'> & {
+        spec: pulumi.Input<JobSpec | k8s.types.input.batch.v1.JobSpec>;
+    };
+    type CronJobSpec = Omit<k8s.types.input.batch.v1.CronJobSpec, 'jobTemplate'> & {
+        template: pulumi.Input<Pod>;
+    };
+    type CronJob = Omit<k8s.types.input.batch.v1.CronJob, 'spec'> & {
+        spec: pulumi.Input<CronJobSpec | k8s.types.input.batch.v1.CronJobSpec>;
+    };
+    type PodBuilderDeploymentSpec = Omit<k8s.types.input.apps.v1.DeploymentSpec, 'selector' | 'template'>;
+    type PodBuilderJobSpec = Omit<k8s.types.input.batch.v1.JobSpec, 'template'>;
+}
+export declare class PodBuilder {
+    readonly podSpec: pulumi.Output<k8s.types.input.core.v1.PodSpec>;
+    private readonly podName;
+    constructor(args: types.PodSpec);
+    asDeploymentSpec(args?: types.PodBuilderDeploymentSpec): pulumi.Output<k8s.types.input.apps.v1.DeploymentSpec>;
+    asStatefulSetSpec(args?: {
+        replicas?: number;
+    }): pulumi.Output<k8s.types.input.apps.v1.StatefulSetSpec>;
+    asJobSpec(args?: types.PodBuilderJobSpec): pulumi.Output<k8s.types.input.batch.v1.JobSpec>;
+    asCronJobSpec({ schedule, concurrencyPolicy, failedJobsHistoryLimit, startingDeadlineSeconds, suspend, successfulJobsHistoryLimit, ...args }: Partial<types.PodBuilderJobSpec> & Omit<k8s.types.input.batch.v1.CronJobSpec, 'jobTemplate'>): pulumi.Output<k8s.types.input.batch.v1.CronJobSpec>;
+}
+export declare class Pod extends k8s.core.v1.Pod {
+    constructor(name: string, args: types.Pod, opts?: pulumi.CustomResourceOptions);
+}
+export declare class Deployment extends k8s.apps.v1.Deployment {
+    readonly name: string;
+    private readonly opts?;
+    constructor(name: string, args: types.Deployment, opts?: pulumi.CustomResourceOptions);
+    createService({ name, ...args }?: types.ServiceSpec): Service;
+}
+export declare class Service extends k8s.core.v1.Service {
+    constructor(name: string, args: types.Service, opts?: pulumi.CustomResourceOptions);
+    /**
+     * Endpoint of the Service. This can be either an IP address or a hostname,
+     * depending on the k8s cluster provider.
+     */
+    get endpoint(): pulumi.Output<string>;
+}
+export declare class StatefulSet extends pulumi.ComponentResource {
+    private readonly name;
+    private readonly opts?;
+    constructor(name: string, args: types.StatefulSet, opts?: pulumi.CustomResourceOptions);
+}
+export declare class Job extends k8s.batch.v1.Job {
+    private readonly name;
+    private readonly opts?;
+    constructor(name: string, args: types.Job, opts?: pulumi.CustomResourceOptions);
+}
+export declare class PersistentVolumeClaim extends k8s.core.v1.PersistentVolumeClaim {
+    constructor(name: string, args: k8s.types.input.core.v1.PersistentVolumeClaim, opts?: pulumi.CustomResourceOptions);
+    mount(destPath: pulumi.Input<string>, srcPath?: pulumi.Input<string>): pulumi.Output<types.VolumeMount>;
+}
+export declare class ConfigMap extends k8s.core.v1.ConfigMap {
+    constructor(name: string, args: k8s.types.input.core.v1.ConfigMap, opts?: pulumi.CustomResourceOptions);
+    mount(destPath: pulumi.Input<string>, srcPath?: pulumi.Input<string>): pulumi.Output<types.VolumeMount>;
+    asEnvValue(key: pulumi.Input<string>): pulumi.Output<k8s.types.input.core.v1.EnvVarSource>;
+}
+export declare class Secret extends k8s.core.v1.Secret {
+    constructor(name: string, args: k8s.types.input.core.v1.Secret, opts?: pulumi.CustomResourceOptions);
+    mount(destPath: pulumi.Input<string>, srcPath?: pulumi.Input<string>): pulumi.Output<types.VolumeMount>;
+    asEnvValue(key: pulumi.Input<string>): pulumi.Output<k8s.types.input.core.v1.EnvVarSource>;
+}

package/KubeX/kx/index.js

@@ -0,0 +1,423 @@
+"use strict";
+// Copyright 2016-2019, Pulumi Corporation.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// Copy from https://github.com/pulumi/pulumi-kubernetesx
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Secret = exports.ConfigMap = exports.PersistentVolumeClaim = exports.Job = exports.StatefulSet = exports.Service = exports.Deployment = exports.Pod = exports.PodBuilder = exports.types = void 0;
+const k8s = require("@pulumi/kubernetes");
+const pulumi = require("@pulumi/pulumi");
+var types;
+(function (types) {
+    let ServiceType;
+    (function (ServiceType) {
+        ServiceType["ClusterIP"] = "ClusterIP";
+        ServiceType["LoadBalancer"] = "LoadBalancer";
+    })(ServiceType = types.ServiceType || (types.ServiceType = {}));
+})(types || (exports.types = types = {}));
+function buildPodSpec(args) {
+    return pulumi.output(args).apply((podSpec) => {
+        const volumes = [];
+        let initContainers = [];
+        if (podSpec.initContainers) {
+            initContainers = podSpec.initContainers.map((container) => buildContainer(container, volumes));
+        }
+        const containers = podSpec.containers.map((container) => buildContainer(container, volumes));
+        return pulumi.output({
+            ...podSpec,
+            initContainers: initContainers,
+            containers: containers,
+            volumes: [...(podSpec.volumes || []), ...volumes],
+        });
+    });
+}
+function buildContainer(container, volumes) {
+    const isEnvMap = (env) => env.length === undefined;
+    const isPortMap = (ports) => ports.length === undefined;
+    const isMountObject = (object) => object.hasOwnProperty('volume');
+    const c = {
+        ...container,
+        env: [],
+        name: '',
+        ports: [],
+        volumeMounts: [],
+    };
+    if (container.name) {
+        c.name = container.name;
+    }
+    else {
+        const re = /(.*\/|^)(?<image>\w+)(:(?<tag>.*))?/;
+        const imageArg = container.image || '';
+        const result = re.exec(imageArg);
+        if (!result) {
+            throw new Error('Failed to parse image name from ' + imageArg);
+        }
+        c.name = result[2];
+    }
+    const env = container.env;
+    if (env) {
+        if (isEnvMap(env)) {
+            Object.keys(env).forEach((key) => {
+                const value = env[key];
+                if (typeof value === 'string') {
+                    c.env.push({ name: key, value: value });
+                }
+                else {
+                    c.env.push({ name: key, valueFrom: value });
+                }
+            });
+        }
+        else {
+            c.env = env;
+        }
+    }
+    const ports = container.ports;
+    if (ports) {
+        if (isPortMap(ports)) {
+            Object.keys(ports).forEach((key) => {
+                const value = ports[key];
+                c.ports.push({ name: key, containerPort: value });
+            });
+        }
+        else {
+            c.ports = ports;
+        }
+    }
+    const volumeMounts = container.volumeMounts;
+    if (volumeMounts) {
+        volumeMounts.forEach((mount) => {
+            if (isMountObject(mount)) {
+                c.volumeMounts.push({
+                    name: mount.volume.name,
+                    mountPath: mount.destPath,
+                    subPath: mount.srcPath,
+                });
+                volumes.push({
+                    ...mount.volume,
+                });
+            }
+            else {
+                c.volumeMounts.push(mount);
+            }
+        });
+    }
+    return c;
+}
+class PodBuilder {
+    podSpec;
+    podName;
+    constructor(args) {
+        this.podSpec = buildPodSpec(args);
+        this.podName = this.podSpec.containers.apply((containers) => pulumi.output(containers[0].name));
+    }
+    asDeploymentSpec(args) {
+        const appLabels = { app: this.podName };
+        const _args = args || {};
+        const deploymentSpec = {
+            ..._args,
+            selector: { matchLabels: appLabels },
+            replicas: _args.replicas ?? 1,
+            template: {
+                metadata: { labels: appLabels },
+                spec: this.podSpec,
+            },
+        };
+        return pulumi.output(deploymentSpec);
+    }
+    asStatefulSetSpec(args) {
+        const appLabels = { app: this.podName };
+        const statefulSetSpec = {
+            selector: { matchLabels: appLabels },
+            replicas: args?.replicas ?? 1,
+            serviceName: '', // This will be auto-generated by kx.StatefulSet.
+            template: {
+                metadata: { labels: appLabels },
+                spec: this.podSpec,
+            },
+        };
+        return pulumi.output(statefulSetSpec);
+    }
+    asJobSpec(args) {
+        const appLabels = { app: this.podName };
+        const jobSpec = {
+            ...args,
+            template: {
+                metadata: { labels: appLabels },
+                spec: this.podSpec,
+            },
+        };
+        return pulumi.output(jobSpec);
+    }
+    asCronJobSpec({ schedule, concurrencyPolicy, failedJobsHistoryLimit, startingDeadlineSeconds, suspend, successfulJobsHistoryLimit, ...args }) {
+        const appLabels = { app: this.podName };
+        const jobSpec = {
+            schedule,
+            concurrencyPolicy,
+            failedJobsHistoryLimit,
+            startingDeadlineSeconds,
+            suspend,
+            successfulJobsHistoryLimit,
+            jobTemplate: {
+                metadata: {
+                    labels: appLabels,
+                    annotations: { 'pulumi.com/skipAwait': 'true' },
+                },
+                spec: this.asJobSpec(args),
+            },
+        };
+        return pulumi.output(jobSpec);
+    }
+}
+exports.PodBuilder = PodBuilder;
+class Pod extends k8s.core.v1.Pod {
+    constructor(name, args, opts) {
+        const isPodBuilder = (object) => object.hasOwnProperty('podSpec');
+        const spec = pulumi
+            .output(args.spec)
+            .apply((specArg) => {
+            if (isPodBuilder(specArg)) {
+                return pulumi.output(specArg.podSpec);
+            }
+            else {
+                return buildPodSpec(specArg);
+            }
+        });
+        super(name, {
+            ...args,
+            spec: spec,
+        }, opts);
+    }
+}
+exports.Pod = Pod;
+class Deployment extends k8s.apps.v1.Deployment {
+    name;
+    opts;
+    constructor(name, args, opts) {
+        const spec = pulumi
+            .output(args)
+            .apply((args) => {
+            const podSpec = buildPodSpec(args.spec.template.spec);
+            return pulumi.output({
+                ...args.spec,
+                template: {
+                    ...args.spec.template,
+                    spec: podSpec,
+                },
+            });
+        });
+        super(name, {
+            ...args,
+            spec: spec,
+        }, opts);
+        this.name = name;
+        this.opts = opts;
+    }
+    createService({ name, ...args } = {}) {
+        const serviceSpec = pulumi
+            .all([this.spec.template.spec.containers, args])
+            .apply(([containers, args]) => {
+            // TODO: handle merging ports from args
+            const ports = {};
+            containers.forEach((container) => {
+                if (container.ports) {
+                    container.ports.forEach((port) => {
+                        ports[port.name] = port.containerPort;
+                    });
+                }
+            });
+            return {
+                ...args,
+                ports: args.ports || ports,
+                selector: this.spec.selector.matchLabels,
+                // TODO: probably need to unwrap args.type in case it's a computed value
+                type: args && args.type,
+            };
+        });
+        return new Service(this.name, {
+            metadata: {
+                name,
+                namespace: this.metadata.namespace,
+                annotations: { 'pulumi.com/skipAwait': 'true' },
+            },
+            spec: serviceSpec,
+        }, { ...this.opts, parent: this, dependsOn: this, deleteBeforeReplace: true });
+    }
+}
+exports.Deployment = Deployment;
+class Service extends k8s.core.v1.Service {
+    constructor(name, args, opts) {
+        const spec = pulumi
+            .output(args)
+            .apply((args) => {
+            const isPortMap = (ports) => ports.length === undefined;
+            let ports = [];
+            const portsArg = args.spec.ports;
+            if (portsArg) {
+                if (isPortMap(portsArg)) {
+                    Object.keys(portsArg).forEach((key) => {
+                        const value = portsArg[key];
+                        ports.push({ name: key, port: value });
+                    });
+                }
+                else {
+                    ports = portsArg;
+                }
+            }
+            return {
+                ...args.spec,
+                ports: ports,
+                type: args.spec.type,
+            };
+        });
+        super(name, {
+            ...args,
+            spec: spec,
+        }, opts);
+    }
+    /**
+     * Endpoint of the Service. This can be either an IP address or a hostname,
+     * depending on the k8s cluster provider.
+     */
+    get endpoint() {
+        return this.status.loadBalancer.ingress.apply((ingress) => {
+            if (ingress.length > 0) {
+                return ingress[0].ip || ingress[0].hostname;
+            }
+            return '';
+        });
+    }
+}
+exports.Service = Service;
+class StatefulSet extends pulumi.ComponentResource {
+    name;
+    opts;
+    constructor(name, args, opts) {
+        const spec = pulumi
+            .output(args)
+            .apply((args) => {
+            const podSpec = buildPodSpec(args.spec.template.spec);
+            return pulumi.output({
+                ...args.spec,
+                serviceName: `${name}-service`,
+                template: {
+                    ...args.spec.template,
+                    spec: podSpec,
+                },
+            });
+        });
+        super('kubernetesx:StatefulSet', name, { ...args, spec: spec }, opts);
+        const statefulSet = new k8s.apps.v1.StatefulSet(name, { ...args, spec: spec }, { ...opts, parent: this });
+        this.name = name;
+        this.opts = opts;
+    }
+}
+exports.StatefulSet = StatefulSet;
+class Job extends k8s.batch.v1.Job {
+    name;
+    opts;
+    constructor(name, args, opts) {
+        const spec = pulumi
+            .output(args)
+            .apply((args) => {
+            const podSpec = buildPodSpec(args.spec.template.spec);
+            return pulumi.output({
+                ...args.spec,
+                template: {
+                    ...args.spec.template,
+                    spec: podSpec,
+                },
+            });
+        });
+        super(name, {
+            ...args,
+            spec: spec,
+        }, opts);
+        this.name = name;
+        this.opts = opts;
+    }
+}
+exports.Job = Job;
+class PersistentVolumeClaim extends k8s.core.v1.PersistentVolumeClaim {
+    constructor(name, args, opts) {
+        super(name, args, opts);
+    }
+    // TODO: define input type?
+    mount(destPath, srcPath) {
+        return pulumi.output({
+            volume: {
+                name: this.metadata.name,
+                persistentVolumeClaim: {
+                    claimName: this.metadata.name,
+                },
+            },
+            destPath: destPath,
+            srcPath: srcPath,
+        });
+    }
+}
+exports.PersistentVolumeClaim = PersistentVolumeClaim;
+class ConfigMap extends k8s.core.v1.ConfigMap {
+    constructor(name, args, opts) {
+        super(name, args, opts);
+    }
+    mount(destPath, srcPath) {
+        return pulumi.output({
+            volume: {
+                name: this.metadata.name,
+                configMap: {
+                    name: this.metadata.name,
+                    // TODO: items
+                },
+            },
+            destPath: destPath,
+            srcPath: srcPath,
+        });
+    }
+    asEnvValue(key) {
+        return pulumi.output({
+            configMapKeyRef: {
+                name: this.metadata.name,
+                key: key,
+            },
+        });
+    }
+}
+exports.ConfigMap = ConfigMap;
+class Secret extends k8s.core.v1.Secret {
+    constructor(name, args, opts) {
+        super(name, args, opts);
+    }
+    mount(destPath, srcPath) {
+        return pulumi.output({
+            volume: {
+                name: this.metadata.name,
+                secret: {
+                    secretName: this.metadata.name,
+                    // TODO: items
+                },
+            },
+            destPath: destPath,
+            srcPath: srcPath,
+        });
+    }
+    asEnvValue(key) {
+        return pulumi.output({
+            secretKeyRef: {
+                name: this.metadata.name,
+                key: key,
+            },
+        });
+    }
+}
+exports.Secret = Secret;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/KubeX/kx/index.ts"],"names":[],"mappings":"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"}