cdk8s-plus-31 2.0.0

package/lib/role.js

@@ -0,0 +1,401 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterRole = exports.Role = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdk8s_1 = require("cdk8s");
+const constructs_1 = require("constructs");
+const base = require("./base");
+const k8s = require("./imports/k8s");
+const rb = require("./role-binding");
+const utils_1 = require("./utils");
+class ImportedRole extends constructs_1.Construct {
+    constructor(scope, id, name) {
+        super(scope, id);
+        this.resourceType = 'roles';
+        this._name = name;
+    }
+    get name() {
+        return this._name;
+    }
+    get apiVersion() {
+        return k8s.KubeRole.GVK.apiVersion;
+    }
+    get apiGroup() {
+        return 'rbac.authorization.k8s.io';
+    }
+    get kind() {
+        return k8s.KubeRole.GVK.kind;
+    }
+    get resourceName() {
+        return this.name;
+    }
+}
+/**
+ * Role is a namespaced, logical grouping of PolicyRules that can be referenced
+ * as a unit by a RoleBinding.
+ */
+class Role extends base.Resource {
+    constructor(scope, id, props = {}) {
+        super(scope, id);
+        this.resourceType = 'roles';
+        this._rules = [];
+        this.apiObject = new k8s.KubeRole(this, 'Resource', {
+            metadata: props.metadata,
+            rules: cdk8s_1.Lazy.any({ produce: () => this.synthesizeRules() }),
+        });
+        for (const rule of props.rules ?? []) {
+            this.allow(rule.verbs, ...rule.resources);
+        }
+    }
+    /**
+     * Imports a role from the cluster as a reference.
+     */
+    static fromRoleName(scope, id, name) {
+        return new ImportedRole(scope, id, name);
+    }
+    /**
+     * Rules associaated with this Role.
+     * Returns a copy, use `allow` to add rules.
+     */
+    get rules() {
+        return [...this._rules];
+    }
+    /**
+     * Add permission to perform a list of HTTP verbs on a collection of
+     * resources.
+     *
+     * @param resources The resource(s) to apply to
+     * @see https://kubernetes.io/docs/reference/access-authn-authz/authorization/#determine-the-request-verb
+     */
+    allow(verbs, ...resources) {
+        this._rules.push({ verbs, resources });
+    }
+    /**
+     * Add "create" permission for the resources.
+     * @param resources The resource(s) to apply to
+     */
+    allowCreate(...resources) {
+        this.allow(['create'], ...resources);
+    }
+    /**
+     * Add "get" permission for the resources.
+     * @param resources The resource(s) to apply to
+     */
+    allowGet(...resources) {
+        this.allow(['get'], ...resources);
+    }
+    /**
+     * Add "list" permission for the resources.
+     * @param resources The resource(s) to apply to
+     */
+    allowList(...resources) {
+        this.allow(['list'], ...resources);
+    }
+    /**
+     * Add "watch" permission for the resources.
+     * @param resources The resource(s) to apply to
+     */
+    allowWatch(...resources) {
+        this.allow(['watch'], ...resources);
+    }
+    /**
+     * Add "update" permission for the resources.
+     * @param resources The resource(s) to apply to
+     */
+    allowUpdate(...resources) {
+        this.allow(['update'], ...resources);
+    }
+    /**
+     * Add "patch" permission for the resources.
+     * @param resources The resource(s) to apply to
+     */
+    allowPatch(...resources) {
+        this.allow(['patch'], ...resources);
+    }
+    /**
+     * Add "delete" permission for the resources.
+     * @param resources The resource(s) to apply to
+     */
+    allowDelete(...resources) {
+        this.allow(['delete'], ...resources);
+    }
+    /**
+     * Add "deletecollection" permission for the resources.
+     * @param resources The resource(s) to apply to
+     */
+    allowDeleteCollection(...resources) {
+        this.allow(['deletecollection'], ...resources);
+    }
+    /**
+     * Add "get", "list", and "watch" permissions for the resources.
+     * @param resources The resource(s) to apply to
+     */
+    allowRead(...resources) {
+        this.allow(['get', 'list', 'watch'], ...resources);
+    }
+    /**
+     * Add "get", "list", "watch", "create", "update", "patch", "delete", and
+     * "deletecollection" permissions for the resources.
+     *
+     * @param resources The resource(s) to apply to
+     */
+    allowReadWrite(...resources) {
+        this.allow(['get', 'list', 'watch', 'create', 'update', 'patch', 'delete', 'deletecollection'], ...resources);
+    }
+    /**
+     * Create a RoleBinding that binds the permissions in this Role
+     * to a list of subjects, that will only apply this role's namespace.
+     * @param subjects a list of subjects to bind to
+     */
+    bind(...subjects) {
+        const subjectsAddress = utils_1.address(...subjects);
+        const binding = new rb.RoleBinding(this, `RoleBinding${subjectsAddress}`, {
+            metadata: {
+                namespace: this.metadata.namespace,
+            },
+            role: this,
+        });
+        binding.addSubjects(...subjects);
+        return binding;
+    }
+    synthesizeRules() {
+        const rules = [];
+        for (const rule of this._rules) {
+            for (const resource of rule.resources) {
+                rules.push({
+                    verbs: rule.verbs,
+                    apiGroups: [resource.apiGroup === 'core' ? '' : resource.apiGroup],
+                    resourceNames: resource.resourceName ? [resource.resourceName] : undefined,
+                    resources: resource.resourceType ? [resource.resourceType] : undefined,
+                });
+            }
+        }
+        return rules;
+    }
+}
+exports.Role = Role;
+_a = JSII_RTTI_SYMBOL_1;
+Role[_a] = { fqn: "cdk8s-plus-31.Role", version: "2.0.0" };
+class ImportedClusterRole extends constructs_1.Construct {
+    constructor(scope, id, name) {
+        super(scope, id);
+        this.resourceType = 'clusterroles';
+        this._name = name;
+    }
+    get name() {
+        return this._name;
+    }
+    get apiVersion() {
+        return k8s.KubeClusterRole.GVK.apiVersion;
+    }
+    get apiGroup() {
+        return 'rbac.authorization.k8s.io';
+    }
+    get kind() {
+        return k8s.KubeClusterRole.GVK.kind;
+    }
+    get resourceName() {
+        return this.name;
+    }
+}
+/**
+ * ClusterRole is a cluster level, logical grouping of PolicyRules that can be
+ * referenced as a unit by a RoleBinding or ClusterRoleBinding.
+ */
+class ClusterRole extends base.Resource {
+    constructor(scope, id, props = {}) {
+        super(scope, id);
+        this.resourceType = 'clusterroles';
+        this._labelSelector = {};
+        this._rules = [];
+        this.apiObject = new k8s.KubeClusterRole(this, 'Resource', {
+            metadata: props.metadata,
+            rules: cdk8s_1.Lazy.any({ produce: () => this.synthesizeRules() }),
+            aggregationRule: cdk8s_1.Lazy.any({ produce: () => this.synthesizeAggregationRules() }),
+        });
+        for (const rule of props.rules ?? []) {
+            this.allow(rule.verbs, ...rule.endpoints);
+        }
+        for (const [key, value] of Object.entries(props.aggregationLabels ?? {})) {
+            this.aggregate(key, value);
+        }
+    }
+    /**
+     * Imports a role from the cluster as a reference.
+     */
+    static fromClusterRoleName(scope, id, name) {
+        return new ImportedClusterRole(scope, id, name);
+    }
+    /**
+     * Rules associaated with this Role.
+     * Returns a copy, use `allow` to add rules.
+     */
+    get rules() {
+        return [...this._rules];
+    }
+    /**
+     * Add permission to perform a list of HTTP verbs on a collection of
+     * resources.
+     *
+     * @param endpoints The endpoints(s) to apply to
+     * @see https://kubernetes.io/docs/reference/access-authn-authz/authorization/#determine-the-request-verb
+     */
+    allow(verbs, ...endpoints) {
+        this._rules.push({ verbs, endpoints });
+    }
+    /**
+     * Add "create" permission for the resources.
+     * @param endpoints The resource(s) to apply to
+     */
+    allowCreate(...endpoints) {
+        this.allow(['create'], ...endpoints);
+    }
+    /**
+     * Add "get" permission for the resources.
+     * @param endpoints The resource(s) to apply to
+     */
+    allowGet(...endpoints) {
+        this.allow(['get'], ...endpoints);
+    }
+    /**
+     * Add "list" permission for the resources.
+     * @param endpoints The resource(s) to apply to
+     */
+    allowList(...endpoints) {
+        this.allow(['list'], ...endpoints);
+    }
+    /**
+     * Add "watch" permission for the resources.
+     * @param endpoints The resource(s) to apply to
+     */
+    allowWatch(...endpoints) {
+        this.allow(['watch'], ...endpoints);
+    }
+    /**
+     * Add "update" permission for the resources.
+     * @param endpoints The resource(s) to apply to
+     */
+    allowUpdate(...endpoints) {
+        this.allow(['update'], ...endpoints);
+    }
+    /**
+     * Add "patch" permission for the resources.
+     * @param endpoints The resource(s) to apply to
+     */
+    allowPatch(...endpoints) {
+        this.allow(['patch'], ...endpoints);
+    }
+    /**
+     * Add "delete" permission for the resources.
+     * @param endpoints The resource(s) to apply to
+     */
+    allowDelete(...endpoints) {
+        this.allow(['delete'], ...endpoints);
+    }
+    /**
+     * Add "deletecollection" permission for the resources.
+     * @param endpoints The resource(s) to apply to
+     */
+    allowDeleteCollection(...endpoints) {
+        this.allow(['deletecollection'], ...endpoints);
+    }
+    /**
+     * Add "get", "list", and "watch" permissions for the resources.
+     * @param endpoints The resource(s) to apply to
+     */
+    allowRead(...endpoints) {
+        this.allow(['get', 'list', 'watch'], ...endpoints);
+    }
+    /**
+     * Add "get", "list", "watch", "create", "update", "patch", "delete", and
+     * "deletecollection" permissions for the resources.
+     *
+     * @param endpoints The resource(s) to apply to
+     */
+    allowReadWrite(...endpoints) {
+        this.allow(['get', 'list', 'watch', 'create', 'update', 'patch', 'delete', 'deletecollection'], ...endpoints);
+    }
+    /**
+     * Aggregate rules from roles matching this label selector.
+     */
+    aggregate(key, value) {
+        this._labelSelector[key] = value;
+    }
+    /**
+     * Combines the rules of the argument ClusterRole into this ClusterRole
+     * using aggregation labels.
+     * @param rol
+     */
+    combine(rol) {
+        const key = `cdk8s.cluster-role/aggregate-to-${cdk8s_1.Names.toLabelValue(this)}`;
+        const value = 'true';
+        rol.metadata.addLabel(key, value);
+        this.aggregate(key, value);
+    }
+    /**
+     * Create a RoleBinding that binds the permissions in this ClusterRole
+     * to a list of subjects, that will only apply to the given namespace.
+     * @param namespace the namespace to limit permissions to.
+     * @param subjects a list of subjects to bind to
+     */
+    bindInNamespace(namespace, ...subjects) {
+        const binding = new rb.RoleBinding(this, `RoleBinding-${namespace}`, {
+            metadata: {
+                namespace,
+            },
+            role: this,
+        });
+        binding.addSubjects(...subjects);
+        return binding;
+    }
+    /**
+     * Create a ClusterRoleBinding that binds the permissions in this
+     * ClusterRole to a list of subjects, without namespace restrictions.
+     * @param subjects a list of subjects to bind to
+     */
+    bind(...subjects) {
+        const binding = new rb.ClusterRoleBinding(this, 'ClusterRoleBinding', {
+            role: this,
+        });
+        binding.addSubjects(...subjects);
+        return binding;
+    }
+    synthesizeRules() {
+        const rules = [];
+        for (const rule of this._rules) {
+            for (const endpoint of rule.endpoints) {
+                const resource = endpoint.asApiResource();
+                const nonResource = endpoint.asNonApiResource();
+                if (resource && nonResource) {
+                    throw new Error('Endpoint must be either resource or non resource. not both.');
+                }
+                if (!resource && !nonResource) {
+                    throw new Error('Endpoint must be either resource or non resource. not neither.');
+                }
+                if (resource) {
+                    rules.push({
+                        apiGroups: [resource.apiGroup === 'core' ? '' : resource.apiGroup],
+                        resources: [resource.resourceType],
+                        resourceNames: resource.resourceName ? [resource.resourceName] : [],
+                        verbs: rule.verbs,
+                    });
+                }
+                if (nonResource) {
+                    rules.push({ verbs: rule.verbs, nonResourceUrLs: [nonResource] });
+                }
+            }
+        }
+        return rules;
+    }
+    synthesizeAggregationRules() {
+        if (Object.keys(this._labelSelector).length === 0) {
+            return undefined;
+        }
+        return { clusterRoleSelectors: [{ matchLabels: this._labelSelector }] };
+    }
+}
+exports.ClusterRole = ClusterRole;
+_b = JSII_RTTI_SYMBOL_1;
+ClusterRole[_b] = { fqn: "cdk8s-plus-31.ClusterRole", version: "2.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"role.js","sourceRoot":"","sources":["../src/role.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApiObject, Lazy, Names } from 'cdk8s';\nimport { Construct } from 'constructs';\nimport { IApiResource, IApiEndpoint } from './api-resource';\nimport * as base from './base';\nimport * as k8s from './imports/k8s';\nimport * as rb from './role-binding';\nimport { address } from './utils';\n\n/**\n * A reference to any Role or ClusterRole.\n */\nexport interface IRole extends base.IResource {\n\n}\n\n/**\n * Properties for `Role`.\n */\nexport interface RoleProps extends base.ResourceProps {\n\n  /**\n   * A list of rules the role should allow.\n   *\n   * @default []\n   */\n  readonly rules?: RolePolicyRule[];\n}\n\n/**\n * Policy rule of a `Role.\n */\nexport interface RolePolicyRule {\n\n  /**\n   * Verbs to allow. (e.g ['get', 'watch'])\n   */\n  readonly verbs: string[];\n\n  /**\n   * Resources this rule applies to.\n   */\n  readonly resources: IApiResource[];\n}\n\nclass ImportedRole extends Construct implements IRole {\n\n  private readonly _name: string;\n\n  public readonly resourceType = 'roles';\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.KubeRole.GVK.apiVersion;\n  }\n\n  public get apiGroup(): string {\n    return 'rbac.authorization.k8s.io';\n  }\n\n  public get kind(): string {\n    return k8s.KubeRole.GVK.kind;\n  }\n\n  public get resourceName(): string {\n    return this.name;\n  }\n\n}\n\n/**\n * Role is a namespaced, logical grouping of PolicyRules that can be referenced\n * as a unit by a RoleBinding.\n */\nexport class Role extends base.Resource implements IRole {\n\n  /**\n   * Imports a role from the cluster as a reference.\n   */\n  public static fromRoleName(scope: Construct, id: string, name: string): IRole {\n    return new ImportedRole(scope, id, name);\n  }\n\n  /**\n   * @see base.Resource.apiObject\n   */\n  protected readonly apiObject: ApiObject;\n\n  public readonly resourceType = 'roles';\n\n  private readonly _rules: Array<RolePolicyRule> = [];\n\n  constructor(scope: Construct, id: string, props: RoleProps = {}) {\n    super(scope, id);\n\n    this.apiObject = new k8s.KubeRole(this, 'Resource', {\n      metadata: props.metadata,\n      rules: Lazy.any({ produce: () => this.synthesizeRules() }),\n    });\n\n    for (const rule of props.rules ?? []) {\n      this.allow(rule.verbs, ...rule.resources);\n    }\n  }\n\n  /**\n   * Rules associaated with this Role.\n   * Returns a copy, use `allow` to add rules.\n   */\n  public get rules(): RolePolicyRule[] {\n    return [...this._rules];\n  }\n\n  /**\n   * Add permission to perform a list of HTTP verbs on a collection of\n   * resources.\n   *\n   * @param resources The resource(s) to apply to\n   * @see https://kubernetes.io/docs/reference/access-authn-authz/authorization/#determine-the-request-verb\n   */\n  public allow(verbs: string[], ...resources: IApiResource[]): void {\n    this._rules.push({ verbs, resources });\n  }\n\n  /**\n   * Add \"create\" permission for the resources.\n   * @param resources The resource(s) to apply to\n   */\n  public allowCreate(...resources: IApiResource[]): void {\n    this.allow(['create'], ...resources);\n  }\n\n  /**\n   * Add \"get\" permission for the resources.\n   * @param resources The resource(s) to apply to\n   */\n  public allowGet(...resources: IApiResource[]): void {\n    this.allow(['get'], ...resources);\n  }\n\n  /**\n   * Add \"list\" permission for the resources.\n   * @param resources The resource(s) to apply to\n   */\n  public allowList(...resources: IApiResource[]): void {\n    this.allow(['list'], ...resources);\n  }\n\n  /**\n   * Add \"watch\" permission for the resources.\n   * @param resources The resource(s) to apply to\n   */\n  public allowWatch(...resources: IApiResource[]): void {\n    this.allow(['watch'], ...resources);\n  }\n\n  /**\n   * Add \"update\" permission for the resources.\n   * @param resources The resource(s) to apply to\n   */\n  public allowUpdate(...resources: IApiResource[]): void {\n    this.allow(['update'], ...resources);\n  }\n\n  /**\n   * Add \"patch\" permission for the resources.\n   * @param resources The resource(s) to apply to\n   */\n  public allowPatch(...resources: IApiResource[]): void {\n    this.allow(['patch'], ...resources);\n  }\n\n  /**\n   * Add \"delete\" permission for the resources.\n   * @param resources The resource(s) to apply to\n   */\n  public allowDelete(...resources: IApiResource[]): void {\n    this.allow(['delete'], ...resources);\n  }\n\n  /**\n   * Add \"deletecollection\" permission for the resources.\n   * @param resources The resource(s) to apply to\n   */\n  public allowDeleteCollection(...resources: IApiResource[]): void {\n    this.allow(['deletecollection'], ...resources);\n  }\n\n  /**\n   * Add \"get\", \"list\", and \"watch\" permissions for the resources.\n   * @param resources The resource(s) to apply to\n   */\n  public allowRead(...resources: IApiResource[]): void {\n    this.allow(['get', 'list', 'watch'], ...resources);\n  }\n\n  /**\n   * Add \"get\", \"list\", \"watch\", \"create\", \"update\", \"patch\", \"delete\", and\n   * \"deletecollection\" permissions for the resources.\n   *\n   * @param resources The resource(s) to apply to\n   */\n  public allowReadWrite(...resources: IApiResource[]): void {\n    this.allow(['get', 'list', 'watch', 'create', 'update', 'patch', 'delete', 'deletecollection'], ...resources);\n  }\n\n  /**\n   * Create a RoleBinding that binds the permissions in this Role\n   * to a list of subjects, that will only apply this role's namespace.\n   * @param subjects a list of subjects to bind to\n   */\n  public bind(...subjects: rb.ISubject[]): rb.RoleBinding {\n    const subjectsAddress = address(...subjects);\n    const binding = new rb.RoleBinding(this, `RoleBinding${subjectsAddress}`, {\n      metadata: {\n        namespace: this.metadata.namespace,\n      },\n      role: this,\n    });\n    binding.addSubjects(...subjects);\n    return binding;\n  }\n\n  private synthesizeRules(): k8s.PolicyRule[] {\n    const rules: k8s.PolicyRule[] = [];\n    for (const rule of this._rules) {\n      for (const resource of rule.resources) {\n        rules.push({\n          verbs: rule.verbs,\n          apiGroups: [resource.apiGroup === 'core' ? '' : resource.apiGroup],\n          resourceNames: resource.resourceName ? [resource.resourceName] : undefined,\n          resources: resource.resourceType ? [resource.resourceType] : undefined,\n        });\n      }\n    }\n    return rules;\n  }\n}\n\n/**\n * Represents a cluster-level role.\n */\nexport interface IClusterRole extends base.IResource {\n\n}\n\n/**\n * Properties for `ClusterRole`.\n */\nexport interface ClusterRoleProps extends base.ResourceProps {\n\n  /**\n    * A list of rules the role should allow.\n    *\n    * @default []\n    */\n  readonly rules?: ClusterRolePolicyRule[];\n\n  /**\n    * Specify labels that should be used to locate ClusterRoles, whose rules\n    * will be automatically filled into this ClusterRole's rules.\n    */\n  readonly aggregationLabels?: { [key: string]: string };\n}\n\n/**\n * Policy rule of a `ClusterRole.\n */\nexport interface ClusterRolePolicyRule {\n\n  /**\n   * Verbs to allow. (e.g ['get', 'watch'])\n   */\n  readonly verbs: string[];\n\n  /**\n   * Endpoints this rule applies to. Can be either api resources\n   * or non api resources.\n   */\n  readonly endpoints: IApiEndpoint[];\n}\n\nclass ImportedClusterRole extends Construct implements IClusterRole {\n\n  private readonly _name: string;\n\n  public readonly resourceType: string = 'clusterroles';\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.KubeClusterRole.GVK.apiVersion;\n  }\n\n  public get apiGroup(): string {\n    return 'rbac.authorization.k8s.io';\n  }\n\n  public get kind(): string {\n    return k8s.KubeClusterRole.GVK.kind;\n  }\n\n  public get resourceName(): string {\n    return this.name;\n  }\n\n}\n\n/**\n * ClusterRole is a cluster level, logical grouping of PolicyRules that can be\n * referenced as a unit by a RoleBinding or ClusterRoleBinding.\n */\nexport class ClusterRole extends base.Resource implements IClusterRole, IRole {\n\n  /**\n   * Imports a role from the cluster as a reference.\n   */\n  public static fromClusterRoleName(scope: Construct, id: string, name: string): IClusterRole {\n    return new ImportedClusterRole(scope, id, name);\n  }\n\n  /**\n   * @see base.Resource.apiObject\n   */\n  protected readonly apiObject: ApiObject;\n\n  public readonly resourceType = 'clusterroles';\n\n  private readonly _labelSelector: Record<string, string> = {};\n  private readonly _rules: Array<ClusterRolePolicyRule> = [];\n\n  constructor(scope: Construct, id: string, props: ClusterRoleProps = {}) {\n    super(scope, id);\n\n    this.apiObject = new k8s.KubeClusterRole(this, 'Resource', {\n      metadata: props.metadata,\n      rules: Lazy.any({ produce: () => this.synthesizeRules() }),\n      aggregationRule: Lazy.any({ produce: () => this.synthesizeAggregationRules() }),\n    });\n\n    for (const rule of props.rules ?? []) {\n      this.allow(rule.verbs, ...rule.endpoints);\n    }\n\n    for (const [key, value] of Object.entries(props.aggregationLabels ?? {})) {\n      this.aggregate(key, value);\n    }\n  }\n\n  /**\n   * Rules associaated with this Role.\n   * Returns a copy, use `allow` to add rules.\n   */\n  public get rules(): ClusterRolePolicyRule[] {\n    return [...this._rules];\n  }\n\n  /**\n   * Add permission to perform a list of HTTP verbs on a collection of\n   * resources.\n   *\n   * @param endpoints The endpoints(s) to apply to\n   * @see https://kubernetes.io/docs/reference/access-authn-authz/authorization/#determine-the-request-verb\n   */\n  public allow(verbs: string[], ...endpoints: IApiEndpoint[]): void {\n    this._rules.push({ verbs, endpoints });\n  }\n\n  /**\n   * Add \"create\" permission for the resources.\n   * @param endpoints The resource(s) to apply to\n   */\n  public allowCreate(...endpoints: IApiEndpoint[]): void {\n    this.allow(['create'], ...endpoints);\n  }\n\n  /**\n   * Add \"get\" permission for the resources.\n   * @param endpoints The resource(s) to apply to\n   */\n  public allowGet(...endpoints: IApiEndpoint[]): void {\n    this.allow(['get'], ...endpoints);\n  }\n\n  /**\n   * Add \"list\" permission for the resources.\n   * @param endpoints The resource(s) to apply to\n   */\n  public allowList(...endpoints: IApiEndpoint[]): void {\n    this.allow(['list'], ...endpoints);\n  }\n\n  /**\n   * Add \"watch\" permission for the resources.\n   * @param endpoints The resource(s) to apply to\n   */\n  public allowWatch(...endpoints: IApiEndpoint[]): void {\n    this.allow(['watch'], ...endpoints);\n  }\n\n  /**\n   * Add \"update\" permission for the resources.\n   * @param endpoints The resource(s) to apply to\n   */\n  public allowUpdate(...endpoints: IApiEndpoint[]): void {\n    this.allow(['update'], ...endpoints);\n  }\n\n  /**\n   * Add \"patch\" permission for the resources.\n   * @param endpoints The resource(s) to apply to\n   */\n  public allowPatch(...endpoints: IApiEndpoint[]): void {\n    this.allow(['patch'], ...endpoints);\n  }\n\n  /**\n   * Add \"delete\" permission for the resources.\n   * @param endpoints The resource(s) to apply to\n   */\n  public allowDelete(...endpoints: IApiEndpoint[]): void {\n    this.allow(['delete'], ...endpoints);\n  }\n\n  /**\n   * Add \"deletecollection\" permission for the resources.\n   * @param endpoints The resource(s) to apply to\n   */\n  public allowDeleteCollection(...endpoints: IApiEndpoint[]): void {\n    this.allow(['deletecollection'], ...endpoints);\n  }\n\n  /**\n   * Add \"get\", \"list\", and \"watch\" permissions for the resources.\n   * @param endpoints The resource(s) to apply to\n   */\n  public allowRead(...endpoints: IApiEndpoint[]): void {\n    this.allow(['get', 'list', 'watch'], ...endpoints);\n  }\n\n  /**\n   * Add \"get\", \"list\", \"watch\", \"create\", \"update\", \"patch\", \"delete\", and\n   * \"deletecollection\" permissions for the resources.\n   *\n   * @param endpoints The resource(s) to apply to\n   */\n  public allowReadWrite(...endpoints: IApiEndpoint[]): void {\n    this.allow(['get', 'list', 'watch', 'create', 'update', 'patch', 'delete', 'deletecollection'], ...endpoints);\n  }\n\n  /**\n   * Aggregate rules from roles matching this label selector.\n   */\n  public aggregate(key: string, value: string): void {\n    this._labelSelector[key] = value;\n  }\n\n  /**\n   * Combines the rules of the argument ClusterRole into this ClusterRole\n   * using aggregation labels.\n   * @param rol\n   */\n  public combine(rol: ClusterRole): void {\n    const key = `cdk8s.cluster-role/aggregate-to-${Names.toLabelValue(this)}`;\n    const value = 'true';\n    rol.metadata.addLabel(key, value);\n    this.aggregate(key, value);\n  }\n\n  /**\n   * Create a RoleBinding that binds the permissions in this ClusterRole\n   * to a list of subjects, that will only apply to the given namespace.\n   * @param namespace the namespace to limit permissions to.\n   * @param subjects a list of subjects to bind to\n   */\n  public bindInNamespace(namespace: string, ...subjects: rb.ISubject[]): rb.RoleBinding {\n    const binding = new rb.RoleBinding(this, `RoleBinding-${namespace}`, {\n      metadata: {\n        namespace,\n      },\n      role: this,\n    });\n    binding.addSubjects(...subjects);\n    return binding;\n  }\n\n  /**\n   * Create a ClusterRoleBinding that binds the permissions in this\n   * ClusterRole to a list of subjects, without namespace restrictions.\n   * @param subjects a list of subjects to bind to\n   */\n  public bind(...subjects: rb.ISubject[]): rb.ClusterRoleBinding {\n    const binding = new rb.ClusterRoleBinding(this, 'ClusterRoleBinding', {\n      role: this,\n    });\n    binding.addSubjects(...subjects);\n    return binding;\n  }\n\n  private synthesizeRules(): k8s.PolicyRule[] {\n    const rules: k8s.PolicyRule[] = [];\n    for (const rule of this._rules) {\n      for (const endpoint of rule.endpoints) {\n        const resource = endpoint.asApiResource();\n        const nonResource = endpoint.asNonApiResource();\n\n        if (resource && nonResource) {\n          throw new Error('Endpoint must be either resource or non resource. not both.');\n        }\n\n        if (!resource && !nonResource) {\n          throw new Error('Endpoint must be either resource or non resource. not neither.');\n        }\n\n        if (resource) {\n          rules.push({\n            apiGroups: [resource.apiGroup === 'core' ? '' : resource.apiGroup],\n            resources: [resource.resourceType],\n            resourceNames: resource.resourceName ? [resource.resourceName] : [],\n            verbs: rule.verbs,\n          });\n        }\n        if (nonResource) {\n          rules.push({ verbs: rule.verbs, nonResourceUrLs: [nonResource] });\n        }\n      }\n\n    }\n    return rules;\n  }\n\n  private synthesizeAggregationRules(): k8s.AggregationRule | undefined {\n    if (Object.keys(this._labelSelector).length === 0) {\n      return undefined;\n    }\n\n    return { clusterRoleSelectors: [{ matchLabels: this._labelSelector }] };\n  }\n}\n"]}

package/lib/secret.d.ts

@@ -0,0 +1,195 @@
+import { ApiObject } from 'cdk8s';
+import { Construct } from 'constructs';
+import * as base from './base';
+import { EnvValue, EnvValueFromSecretOptions } from './container';
+import * as serviceaccount from './service-account';
+/**
+ * Common properties for `Secret`.
+ */
+export interface CommonSecretProps extends base.ResourceProps {
+    /**
+     * If set to true, ensures that data stored in the Secret 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;
+}
+/**
+ * Options for `Secret`.
+ */
+export interface SecretProps extends CommonSecretProps {
+    /**
+     * stringData allows specifying non-binary secret data in string form. It is
+     * provided as a write-only convenience method. All keys and values are merged
+     * into the data field on write, overwriting any existing values. It is never
+     * output when reading from the API.
+     */
+    readonly stringData?: {
+        [key: string]: string;
+    };
+    /**
+     * Optional type associated with the secret.  Used to facilitate programmatic
+     * handling of secret data by various controllers.
+     *
+     * @default undefined - Don't set a type.
+     */
+    readonly type?: string;
+}
+export interface ISecret extends base.IResource {
+    /**
+     * Returns EnvValue object from a secret's key.
+     * @param key Secret's key
+     * @param options Additional EnvValue options
+     */
+    envValue(key: string, options?: EnvValueFromSecretOptions): EnvValue;
+}
+/**
+ * Represents a specific value in JSON secret.
+ */
+export interface SecretValue {
+    /**
+     * The secret
+     */
+    readonly secret: ISecret;
+    /**
+     * The JSON key
+     */
+    readonly key: string;
+}
+/**
+ * Kubernetes Secrets let you store and manage sensitive information, such as
+ * passwords, OAuth tokens, and ssh keys. Storing confidential information in a
+ * Secret is safer and more flexible than putting it verbatim in a Pod
+ * definition or in a container image.
+ *
+ * @see https://kubernetes.io/docs/concepts/configuration/secret
+ */
+export declare class Secret extends base.Resource implements ISecret {
+    /**
+     * Imports a secret from the cluster as a reference.
+     */
+    static fromSecretName(scope: Construct, id: string, name: string): ISecret;
+    /**
+     * @see base.Resource.apiObject
+     */
+    protected readonly apiObject: ApiObject;
+    readonly resourceType = "secrets";
+    /**
+     * Whether or not the secret is immutable.
+     */
+    readonly immutable: boolean;
+    private readonly stringData;
+    constructor(scope: Construct, id: string, props?: SecretProps);
+    /**
+     * Adds a string data field to the secret.
+     * @param key Key
+     * @param value Value
+     */
+    addStringData(key: string, value: string): void;
+    /**
+     * Gets a string data by key or undefined
+     * @param key Key
+     */
+    getStringData(key: string): string | undefined;
+    envValue(key: string, options?: EnvValueFromSecretOptions): EnvValue;
+}
+/**
+ * Options for `BasicAuthSecret`.
+ */
+export interface BasicAuthSecretProps extends CommonSecretProps {
+    /**
+     * The user name for authentication
+     */
+    readonly username: string;
+    /**
+     * The password or token for authentication
+     */
+    readonly password: string;
+}
+/**
+ * Create a secret for basic authentication.
+ *
+ * @see https://kubernetes.io/docs/concepts/configuration/secret/#basic-authentication-secret
+ */
+export declare class BasicAuthSecret extends Secret {
+    constructor(scope: Construct, id: string, props: BasicAuthSecretProps);
+}
+/**
+ * Options for `SshAuthSecret`.
+ */
+export interface SshAuthSecretProps extends CommonSecretProps {
+    /**
+     * The SSH private key to use
+     */
+    readonly sshPrivateKey: string;
+}
+/**
+ * Create a secret for ssh authentication.
+ *
+ * @see https://kubernetes.io/docs/concepts/configuration/secret/#ssh-authentication-secrets
+ */
+export declare class SshAuthSecret extends Secret {
+    constructor(scope: Construct, id: string, props: SshAuthSecretProps);
+}
+/**
+ * Options for `ServiceAccountTokenSecret`.
+ */
+export interface ServiceAccountTokenSecretProps extends CommonSecretProps {
+    /**
+     * The service account to store a secret for
+     */
+    readonly serviceAccount: serviceaccount.IServiceAccount;
+}
+/**
+ * Create a secret for a service account token.
+ *
+ * @see https://kubernetes.io/docs/concepts/configuration/secret/#service-account-token-secrets
+ */
+export declare class ServiceAccountTokenSecret extends Secret {
+    constructor(scope: Construct, id: string, props: ServiceAccountTokenSecretProps);
+}
+/**
+ * Options for `TlsSecret`.
+ */
+export interface TlsSecretProps extends CommonSecretProps {
+    /**
+     * The TLS cert
+     */
+    readonly tlsCert: string;
+    /**
+     * The TLS key
+     */
+    readonly tlsKey: string;
+}
+/**
+ * Create a secret for storing a TLS certificate and its associated key.
+ *
+ * @see https://kubernetes.io/docs/concepts/configuration/secret/#tls-secrets
+ */
+export declare class TlsSecret extends Secret {
+    constructor(scope: Construct, id: string, props: TlsSecretProps);
+}
+/**
+ * Options for `DockerConfigSecret`.
+ */
+export interface DockerConfigSecretProps extends CommonSecretProps {
+    /**
+     * JSON content to provide for the `~/.docker/config.json` file. This will
+     * be stringified and inserted as stringData.
+     *
+     * @see https://docs.docker.com/engine/reference/commandline/cli/#sample-configuration-file
+     */
+    readonly data: {
+        [key: string]: any;
+    };
+}
+/**
+ * Create a secret for storing credentials for accessing a container image
+ * registry.
+ *
+ * @see https://kubernetes.io/docs/concepts/configuration/secret/#docker-config-secrets
+ */
+export declare class DockerConfigSecret extends Secret {
+    constructor(scope: Construct, id: string, props: DockerConfigSecretProps);
+}