cdk8s-plus-31 2.0.0

package/lib/config-map.d.ts

@@ -0,0 +1,126 @@
+import { ApiObject } from 'cdk8s';
+import { Construct } from 'constructs';
+import * as base from './base';
+/**
+ * Properties for initialization of `ConfigMap`.
+ */
+export interface ConfigMapProps extends base.ResourceProps {
+    /**
+     * BinaryData contains the binary data.
+     *
+     * Each key must consist of alphanumeric characters, '-', '_' or '.'.
+     * BinaryData can contain byte sequences that are not in the UTF-8 range. The
+     * keys stored in BinaryData must not overlap with the ones in the Data field,
+     * this is enforced during validation process.
+     *
+     * You can also add binary data using `configMap.addBinaryData()`.
+     */
+    readonly binaryData?: {
+        [key: string]: string;
+    };
+    /**
+     * Data contains the configuration data.
+     *
+     * Each key must consist of alphanumeric characters, '-', '_' or '.'. Values
+     * with non-UTF-8 byte sequences must use the BinaryData field. The keys
+     * stored in Data must not overlap with the keys in the BinaryData field, this
+     * is enforced during validation process.
+     *
+     * You can also add data using `configMap.addData()`.
+     */
+    readonly data?: {
+        [key: string]: string;
+    };
+    /**
+     * If set to true, ensures that data stored in the ConfigMap cannot be updated (only object metadata can be modified).
+     * If not set to true, the field can be modified at any time.
+     *
+     * @default false
+     */
+    readonly immutable?: boolean;
+}
+/**
+ * Represents a config map.
+ */
+export interface IConfigMap extends base.IResource {
+}
+/**
+ * ConfigMap holds configuration data for pods to consume.
+ */
+export declare class ConfigMap extends base.Resource implements IConfigMap {
+    /**
+     * Represents a ConfigMap created elsewhere.
+     */
+    static fromConfigMapName(scope: Construct, id: string, name: string): IConfigMap;
+    /**
+     * @see base.Resource.apiObject
+     */
+    protected readonly apiObject: ApiObject;
+    readonly resourceType = "configmaps";
+    private readonly _binaryData;
+    private readonly _data;
+    /**
+     * Whether or not this config map is immutable.
+     */
+    readonly immutable: boolean;
+    constructor(scope: Construct, id: string, props?: ConfigMapProps);
+    /**
+     * Adds a data entry to the config map.
+     * @param key The key
+     * @param value The value
+     *
+     * @throws if there is either a `data` or `binaryData` entry with the same key
+     */
+    addData(key: string, value: string): void;
+    /**
+     * The data associated with this config map.
+     *
+     * Returns an copy. To add data records, use `addData()` or `addBinaryData()`.
+     */
+    get data(): Record<string, string>;
+    /**
+     * Adds a binary data entry to the config map. BinaryData can contain byte
+     * sequences that are not in the UTF-8 range.
+     * @param key The key
+     * @param value The value
+     *
+     * @throws if there is either a `data` or `binaryData` entry with the same key
+     */
+    addBinaryData(key: string, value: string): void;
+    /**
+     * The binary data associated with this config map.
+     *
+     * Returns a copy. To add data records, use `addBinaryData()` or `addData()`.
+     */
+    get binaryData(): Record<string, string>;
+    /**
+     * Adds a file to the ConfigMap.
+     * @param localFile The path to the local file
+     * @param key The ConfigMap key (default to the file name).
+     */
+    addFile(localFile: string, key?: string): void;
+    /**
+     * Adds a directory to the ConfigMap.
+     * @param localDir A path to a local directory
+     * @param options Options
+     */
+    addDirectory(localDir: string, options?: AddDirectoryOptions): void;
+    private verifyKeyAvailable;
+    private synthesizeData;
+    private synthesizeBinaryData;
+}
+/**
+ * Options for `configmap.addDirectory()`
+ */
+export interface AddDirectoryOptions {
+    /**
+     * A prefix to add to all keys in the config map.
+     * @default ""
+     */
+    readonly keyPrefix?: string;
+    /**
+     * Glob patterns to exclude when adding files.
+     * @default - include all files
+     */
+    readonly exclude?: string[];
+}

package/lib/config-map.js

@@ -0,0 +1,159 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigMap = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const configmap = require("fs");
+const path = require("path");
+const cdk8s_1 = require("cdk8s");
+const constructs_1 = require("constructs");
+const minimatch_1 = require("minimatch");
+const base = require("./base");
+const k8s = require("./imports/k8s");
+const utils_1 = require("./utils");
+class ImportedConfigMap extends constructs_1.Construct {
+    constructor(scope, id, name) {
+        super(scope, id);
+        this.resourceType = 'configmaps';
+        this._name = name;
+    }
+    get name() {
+        return this._name;
+    }
+    get apiVersion() {
+        return k8s.KubeConfigMap.GVK.apiVersion;
+    }
+    get apiGroup() {
+        return '';
+    }
+    get kind() {
+        return k8s.KubeConfigMap.GVK.kind;
+    }
+    get resourceName() {
+        return this.name;
+    }
+}
+/**
+ * ConfigMap holds configuration data for pods to consume.
+ */
+class ConfigMap extends base.Resource {
+    constructor(scope, id, props = {}) {
+        super(scope, id);
+        this.resourceType = 'configmaps';
+        this._binaryData = {};
+        this._data = {};
+        this.immutable = props.immutable ?? false;
+        this.apiObject = new k8s.KubeConfigMap(this, 'Resource', {
+            metadata: props.metadata,
+            // we need lazy here because we filter empty
+            data: cdk8s_1.Lazy.any({ produce: () => this.synthesizeData() }),
+            binaryData: cdk8s_1.Lazy.any({ produce: () => this.synthesizeBinaryData() }),
+            immutable: this.immutable,
+        });
+        for (const [k, v] of Object.entries(props.data ?? {})) {
+            this.addData(k, v);
+        }
+        for (const [k, v] of Object.entries(props.binaryData ?? {})) {
+            this.addBinaryData(k, v);
+        }
+    }
+    /**
+     * Represents a ConfigMap created elsewhere.
+     */
+    static fromConfigMapName(scope, id, name) {
+        return new ImportedConfigMap(scope, id, name);
+    }
+    /**
+     * Adds a data entry to the config map.
+     * @param key The key
+     * @param value The value
+     *
+     * @throws if there is either a `data` or `binaryData` entry with the same key
+     */
+    addData(key, value) {
+        this.verifyKeyAvailable(key);
+        this._data[key] = value;
+    }
+    /**
+     * The data associated with this config map.
+     *
+     * Returns an copy. To add data records, use `addData()` or `addBinaryData()`.
+     */
+    get data() {
+        return { ...this._data };
+    }
+    /**
+     * Adds a binary data entry to the config map. BinaryData can contain byte
+     * sequences that are not in the UTF-8 range.
+     * @param key The key
+     * @param value The value
+     *
+     * @throws if there is either a `data` or `binaryData` entry with the same key
+     */
+    addBinaryData(key, value) {
+        this.verifyKeyAvailable(key);
+        this._binaryData[key] = value;
+    }
+    /**
+     * The binary data associated with this config map.
+     *
+     * Returns a copy. To add data records, use `addBinaryData()` or `addData()`.
+     */
+    get binaryData() {
+        return { ...this._binaryData };
+    }
+    /**
+     * Adds a file to the ConfigMap.
+     * @param localFile The path to the local file
+     * @param key The ConfigMap key (default to the file name).
+     */
+    addFile(localFile, key) {
+        key = key ?? path.basename(localFile);
+        const value = configmap.readFileSync(localFile, 'utf-8');
+        this.addData(key, value);
+    }
+    /**
+     * Adds a directory to the ConfigMap.
+     * @param localDir A path to a local directory
+     * @param options Options
+     */
+    addDirectory(localDir, options = {}) {
+        const exclude = options.exclude ?? [];
+        const shouldInclude = (file) => {
+            for (const pattern of exclude) {
+                const mm = new minimatch_1.Minimatch(pattern);
+                if (mm.match(file)) {
+                    return false;
+                }
+            }
+            return true;
+        };
+        const keyPrefix = options.keyPrefix ?? '';
+        for (const file of configmap.readdirSync(localDir)) {
+            const filePath = path.join(localDir, file);
+            if (configmap.statSync(filePath).isDirectory()) {
+                continue;
+            }
+            if (!shouldInclude(file)) {
+                continue;
+            }
+            const relativeFilePath = keyPrefix + file;
+            this.addFile(filePath, relativeFilePath);
+        }
+    }
+    verifyKeyAvailable(key) {
+        if (key in this._data || key in this._binaryData) {
+            throw new Error(`unable to add a ConfigMap entry with key "${key}". It is already used`);
+        }
+    }
+    synthesizeData() {
+        return utils_1.undefinedIfEmpty(this._data);
+    }
+    synthesizeBinaryData() {
+        return utils_1.undefinedIfEmpty(this._binaryData);
+    }
+}
+exports.ConfigMap = ConfigMap;
+_a = JSII_RTTI_SYMBOL_1;
+ConfigMap[_a] = { fqn: "cdk8s-plus-31.ConfigMap", version: "2.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config-map.js","sourceRoot":"","sources":["../src/config-map.ts"],"names":[],"mappings":"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","sourcesContent":["import * as configmap from 'fs';\nimport * as path from 'path';\nimport { ApiObject, Lazy } from 'cdk8s';\nimport { Construct } from 'constructs';\nimport { Minimatch } from 'minimatch';\nimport * as base from './base';\nimport * as k8s from './imports/k8s';\nimport { undefinedIfEmpty } from './utils';\n\n/**\n * Properties for initialization of `ConfigMap`.\n */\nexport interface ConfigMapProps extends base.ResourceProps {\n  /**\n   * BinaryData contains the binary data.\n   *\n   * Each key must consist of alphanumeric characters, '-', '_' or '.'.\n   * BinaryData can contain byte sequences that are not in the UTF-8 range. The\n   * keys stored in BinaryData must not overlap with the ones in the Data field,\n   * this is enforced during validation process.\n   *\n   * You can also add binary data using `configMap.addBinaryData()`.\n   */\n  readonly binaryData?: { [key: string]: string };\n\n  /**\n   * Data contains the configuration data.\n   *\n   * Each key must consist of alphanumeric characters, '-', '_' or '.'. Values\n   * with non-UTF-8 byte sequences must use the BinaryData field. The keys\n   * stored in Data must not overlap with the keys in the BinaryData field, this\n   * is enforced during validation process.\n   *\n   * You can also add data using `configMap.addData()`.\n   */\n  readonly data?: { [key: string]: string };\n\n  /**\n   * If set to true, ensures that data stored in the ConfigMap cannot be updated (only object metadata can be modified).\n   * If not set to true, the field can be modified at any time.\n   *\n   * @default false\n   */\n  readonly immutable?: boolean;\n\n}\n\n/**\n * Represents a config map.\n */\nexport interface IConfigMap extends base.IResource {\n\n}\n\nclass ImportedConfigMap extends Construct implements IConfigMap {\n\n  private readonly _name: string;\n\n  public readonly resourceType = 'configmaps';\n\n  constructor(scope: Construct, id: string, name: string) {\n    super(scope, id);\n    this._name = name;\n  }\n\n  public get name(): string {\n    return this._name;\n  }\n\n  public get apiVersion(): string {\n    return k8s.KubeConfigMap.GVK.apiVersion;\n  }\n\n  public get apiGroup(): string {\n    return '';\n  }\n\n  public get kind(): string {\n    return k8s.KubeConfigMap.GVK.kind;\n  }\n\n  public get resourceName(): string {\n    return this.name;\n  }\n\n}\n\n/**\n * ConfigMap holds configuration data for pods to consume.\n */\nexport class ConfigMap extends base.Resource implements IConfigMap {\n\n  /**\n   * Represents a ConfigMap created elsewhere.\n   */\n  public static fromConfigMapName(scope: Construct, id: string, name: string): IConfigMap {\n    return new ImportedConfigMap(scope, id, name);\n  }\n\n  /**\n   * @see base.Resource.apiObject\n   */\n  protected readonly apiObject: ApiObject;\n\n  public readonly resourceType = 'configmaps';\n\n  private readonly _binaryData: { [key: string]: string } = { };\n  private readonly _data: { [key: string]: string } = { };\n\n  /**\n   * Whether or not this config map is immutable.\n   */\n  public readonly immutable: boolean;\n\n  public constructor(scope: Construct, id: string, props: ConfigMapProps = { }) {\n    super(scope, id);\n\n    this.immutable = props.immutable ?? false;\n    this.apiObject = new k8s.KubeConfigMap(this, 'Resource', {\n      metadata: props.metadata,\n\n      // we need lazy here because we filter empty\n      data: Lazy.any({ produce: () => this.synthesizeData() }),\n      binaryData: Lazy.any({ produce: () => this.synthesizeBinaryData() }),\n      immutable: this.immutable,\n    });\n\n    for (const [k, v] of Object.entries(props.data ?? { })) {\n      this.addData(k, v);\n    }\n\n    for (const [k, v] of Object.entries(props.binaryData ?? { })) {\n      this.addBinaryData(k, v);\n    }\n\n  }\n\n  /**\n   * Adds a data entry to the config map.\n   * @param key The key\n   * @param value The value\n   *\n   * @throws if there is either a `data` or `binaryData` entry with the same key\n   */\n  public addData(key: string, value: string) {\n    this.verifyKeyAvailable(key);\n\n    this._data[key] = value;\n  }\n\n  /**\n   * The data associated with this config map.\n   *\n   * Returns an copy. To add data records, use `addData()` or `addBinaryData()`.\n   */\n  public get data(): Record<string, string> {\n    return { ...this._data };\n  }\n\n  /**\n   * Adds a binary data entry to the config map. BinaryData can contain byte\n   * sequences that are not in the UTF-8 range.\n   * @param key The key\n   * @param value The value\n   *\n   * @throws if there is either a `data` or `binaryData` entry with the same key\n   */\n  public addBinaryData(key: string, value: string) {\n    this.verifyKeyAvailable(key);\n\n    this._binaryData[key] = value;\n  }\n\n  /**\n   * The binary data associated with this config map.\n   *\n   * Returns a copy. To add data records, use `addBinaryData()` or `addData()`.\n   */\n  public get binaryData(): Record<string, string> {\n    return { ...this._binaryData };\n  }\n\n  /**\n   * Adds a file to the ConfigMap.\n   * @param localFile The path to the local file\n   * @param key The ConfigMap key (default to the file name).\n   */\n  public addFile(localFile: string, key?: string) {\n    key = key ?? path.basename(localFile);\n    const value = configmap.readFileSync(localFile, 'utf-8');\n\n    this.addData(key, value);\n  }\n\n  /**\n   * Adds a directory to the ConfigMap.\n   * @param localDir A path to a local directory\n   * @param options Options\n   */\n  public addDirectory(localDir: string, options: AddDirectoryOptions = { }) {\n    const exclude = options.exclude ?? [];\n    const shouldInclude = (file: string) => {\n      for (const pattern of exclude) {\n        const mm = new Minimatch(pattern);\n        if (mm.match(file)) {\n          return false;\n        }\n      }\n      return true;\n    };\n\n    const keyPrefix = options.keyPrefix ?? '';\n    for (const file of configmap.readdirSync(localDir)) {\n\n      const filePath = path.join(localDir, file);\n\n      if (configmap.statSync(filePath).isDirectory()) {\n        continue;\n      }\n\n      if (!shouldInclude(file)) {\n        continue;\n      }\n\n      const relativeFilePath = keyPrefix + file;\n      this.addFile(filePath, relativeFilePath);\n    }\n  }\n\n  private verifyKeyAvailable(key: string) {\n    if (key in this._data || key in this._binaryData) {\n      throw new Error(`unable to add a ConfigMap entry with key \"${key}\". It is already used`);\n    }\n  }\n\n  private synthesizeData() {\n    return undefinedIfEmpty(this._data);\n  }\n\n  private synthesizeBinaryData() {\n    return undefinedIfEmpty(this._binaryData);\n  }\n}\n\n/**\n * Options for `configmap.addDirectory()`\n */\nexport interface AddDirectoryOptions {\n  /**\n   * A prefix to add to all keys in the config map.\n   * @default \"\"\n   */\n  readonly keyPrefix?: string;\n\n  /**\n   * Glob patterns to exclude when adding files.\n   * @default - include all files\n   */\n  readonly exclude?: string[];\n}\n"]}