cdk8s-plus-36 0.0.1 → 2.0.0

package/lib/role.js

@@ -0,0 +1,441 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 = __importStar(require("./base"));
+const k8s = __importStar(require("./imports/k8s"));
+const rb = __importStar(require("./role-binding"));
+const utils_1 = require("./utils");
+class ImportedRole extends constructs_1.Construct {
+    _name;
+    resourceType = 'roles';
+    constructor(scope, id, name) {
+        super(scope, id);
+        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 {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.Role", version: "2.0.0" };
+    /**
+     * Imports a role from the cluster as a reference.
+     */
+    static fromRoleName(scope, id, name) {
+        return new ImportedRole(scope, id, name);
+    }
+    /**
+     * @see base.Resource.apiObject
+     */
+    apiObject;
+    resourceType = 'roles';
+    _rules = [];
+    constructor(scope, id, props = {}) {
+        super(scope, id);
+        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);
+        }
+    }
+    /**
+     * 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 = (0, 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;
+class ImportedClusterRole extends constructs_1.Construct {
+    _name;
+    resourceType = 'clusterroles';
+    constructor(scope, id, name) {
+        super(scope, id);
+        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 {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.ClusterRole", version: "2.0.0" };
+    /**
+     * Imports a role from the cluster as a reference.
+     */
+    static fromClusterRoleName(scope, id, name) {
+        return new ImportedClusterRole(scope, id, name);
+    }
+    /**
+     * @see base.Resource.apiObject
+     */
+    apiObject;
+    resourceType = 'clusterroles';
+    _labelSelector = {};
+    _rules = [];
+    constructor(scope, id, props = {}) {
+        super(scope, id);
+        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);
+        }
+    }
+    /**
+     * 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;
+//# 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"]}