@aws-cdk/aws-glue-alpha 2.263.0-alpha.0 → 2.265.0-alpha.0

package/lib/catalog.js

@@ -0,0 +1,424 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Catalog = exports.CatalogBase = exports.DataCatalogEncryptionAtRest = exports.CatalogEncryptionMode = void 0;
+const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_glue_1 = require("aws-cdk-lib/aws-glue");
+const aws_kms_1 = require("aws-cdk-lib/aws-kms");
+const core_1 = require("aws-cdk-lib/core");
+const helpers_internal_1 = require("aws-cdk-lib/core/lib/helpers-internal");
+const metadata_resource_1 = require("aws-cdk-lib/core/lib/metadata-resource");
+const prop_injectable_1 = require("aws-cdk-lib/core/lib/prop-injectable");
+/**
+ * The encryption-at-rest mode for a Glue Data Catalog.
+ *
+ * @see https://docs.aws.amazon.com/glue/latest/webapi/API_EncryptionAtRest.html#Glue-Type-EncryptionAtRest-CatalogEncryptionMode
+ */
+var CatalogEncryptionMode;
+(function (CatalogEncryptionMode) {
+    /**
+     * Encryption at rest is disabled.
+     */
+    CatalogEncryptionMode["DISABLED"] = "DISABLED";
+    /**
+     * Server-side encryption (SSE) with an AWS KMS key.
+     */
+    CatalogEncryptionMode["SSE_KMS"] = "SSE-KMS";
+    /**
+     * Server-side encryption (SSE) with an AWS KMS key, using a service role that
+     * AWS Glue assumes to access the key on your behalf.
+     */
+    CatalogEncryptionMode["SSE_KMS_WITH_SERVICE_ROLE"] = "SSE-KMS-WITH-SERVICE-ROLE";
+})(CatalogEncryptionMode || (exports.CatalogEncryptionMode = CatalogEncryptionMode = {}));
+/**
+ * Encryption-at-rest configuration for a Glue Data Catalog.
+ *
+ * The Data Catalog encryption at rest and the connection password encryption
+ * are independent: enabling one does not require the other, and each may use a
+ * different KMS key.
+ *
+ * @see https://docs.aws.amazon.com/glue/latest/webapi/API_EncryptionAtRest.html
+ */
+class DataCatalogEncryptionAtRest {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-glue-alpha.DataCatalogEncryptionAtRest", version: "2.265.0-alpha.0" };
+    /**
+     * Disable encryption at rest for the Data Catalog.
+     */
+    static disabled() {
+        return new DataCatalogEncryptionAtRest(CatalogEncryptionMode.DISABLED);
+    }
+    /**
+     * Encrypt the Data Catalog at rest with an AWS KMS key.
+     *
+     * @param key the KMS key to use. If omitted, an AWS-managed key is used and
+     * the key is not exposed as a grantable resource.
+     */
+    static kms(key) {
+        return new DataCatalogEncryptionAtRest(CatalogEncryptionMode.SSE_KMS, key);
+    }
+    /**
+     * Encrypt the Data Catalog at rest with an AWS KMS key, accessed through a
+     * service role that AWS Glue assumes on your behalf.
+     *
+     * When a customer-managed `key` is provided, the `role` is automatically
+     * granted `kms:Encrypt`/`kms:Decrypt`/`kms:GenerateDataKey*` on it.
+     *
+     * @param role the service role that AWS Glue assumes to access the key.
+     * @param key the KMS key to use. If omitted, an AWS-managed key is used and
+     * the key is not exposed as a grantable resource.
+     */
+    static kmsWithServiceRole(role, key) {
+        return new DataCatalogEncryptionAtRest(CatalogEncryptionMode.SSE_KMS_WITH_SERVICE_ROLE, key, role);
+    }
+    /**
+     * The encryption mode.
+     */
+    mode;
+    /**
+     * The customer-managed KMS key used for encryption at rest, if any.
+     */
+    kmsKey;
+    /**
+     * The service role that AWS Glue assumes to access the KMS key, if any.
+     */
+    serviceRole;
+    constructor(mode, kmsKey, serviceRole) {
+        this.mode = mode;
+        this.kmsKey = kmsKey;
+        this.serviceRole = serviceRole;
+    }
+}
+exports.DataCatalogEncryptionAtRest = DataCatalogEncryptionAtRest;
+/**
+ * Base class for all `ICatalog` implementations. Materializes the single
+ * `CfnDataCatalogEncryptionSettings` resource (targeting its own `catalogId`)
+ * from the encryption options supplied at construction. Encryption is fixed at
+ * construction, so a catalog either carries settings or it does not.
+ */
+class CatalogBase extends core_1.Resource {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-glue-alpha.CatalogBase", version: "2.265.0-alpha.0" };
+    _encryptionKey;
+    _connectionPasswordKey;
+    get encryptionKey() {
+        return this._encryptionKey;
+    }
+    get connectionPasswordKey() {
+        return this._connectionPasswordKey;
+    }
+    get catalogRef() {
+        return {
+            resourceArn: this.catalogArn,
+        };
+    }
+    /**
+     * Emit the catalog's encryption settings from the options fixed at
+     * construction. Subclasses call this once, after `catalogId`/`catalogArn` are
+     * assigned. When neither block is configured, no resource is emitted, avoiding
+     * an empty settings resource that would reset the catalog on deploy.
+     */
+    configureEncryption(options) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_glue_alpha_CatalogEncryptionOptions(options);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.configureEncryption);
+            }
+            throw error;
+        }
+        const atRest = options.encryptionAtRest;
+        const password = options.connectionPasswordEncryption;
+        if (!atRest && !password) {
+            return;
+        }
+        this._encryptionKey = atRest?.kmsKey;
+        this._connectionPasswordKey = password?.kmsKey;
+        // Auto-grant the service role access to the customer-managed key it needs
+        // to encrypt and decrypt catalog data. Nothing to grant for an AWS-managed
+        // key (we don't own its key policy).
+        if (atRest?.serviceRole && atRest.kmsKey) {
+            aws_kms_1.KeyGrants.fromKey(atRest.kmsKey).encryptDecrypt(atRest.serviceRole);
+        }
+        // Two catalog instances that target the same catalog id would each emit a
+        // settings resource and race to overwrite one another via
+        // `PutDataCatalogEncryptionSettings`. Within one stack this is surfaced by
+        // CloudFormation template validation (E3019: duplicate primary identifiers),
+        // so we do not duplicate that check here.
+        new aws_glue_1.CfnDataCatalogEncryptionSettings(this, 'EncryptionSettings', {
+            catalogId: this.catalogId,
+            dataCatalogEncryptionSettings: {
+                encryptionAtRest: atRest
+                    ? {
+                        catalogEncryptionMode: atRest.mode,
+                        sseAwsKmsKeyId: atRest.kmsKey?.keyRef.keyArn,
+                        catalogEncryptionServiceRole: atRest.serviceRole?.roleArn,
+                    }
+                    : undefined,
+                connectionPasswordEncryption: password
+                    ? {
+                        kmsKeyId: password.kmsKey?.keyRef.keyArn,
+                        returnConnectionPasswordEncrypted: password.returnConnectionPasswordEncrypted ?? true,
+                    }
+                    : undefined,
+            },
+        });
+    }
+}
+exports.CatalogBase = CatalogBase;
+/**
+ * The stack-scoped singleton id for the implicit account-wide catalog.
+ */
+const ACCOUNT_CATALOG_UID = '@aws-cdk.aws-glue-alpha.AccountCatalog';
+/**
+ * A Glue Data Catalog.
+ *
+ * Use `Catalog.forAccount(scope)` to obtain the implicit account-wide catalog,
+ * `Catalog.encryptAccount(scope, options)` to configure its Data Catalog
+ * encryption, or `new Catalog(...)` to create an `AWS::Glue::Catalog` resource.
+ */
+let Catalog = (() => {
+    let _classDecorators = [prop_injectable_1.propertyInjectable];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = CatalogBase;
+    var Catalog = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            Catalog = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-glue-alpha.Catalog", version: "2.265.0-alpha.0" };
+        /** Uniquely identifies this class. */
+        static PROPERTY_INJECTION_ID = '@aws-cdk.aws-glue-alpha.Catalog';
+        /**
+         * Obtain the implicit, account-wide Data Catalog.
+         *
+         * The account catalog is not a CloudFormation resource; it always exists. This
+         * returns a stack-scoped singleton, so repeated calls within the same stack
+         * return the same instance.
+         *
+         * This returns the account catalog without managing its encryption. To
+         * configure Data Catalog encryption for the account, use
+         * `Catalog.encryptAccount(scope, options)` instead - it must be called before
+         * the account catalog is first used in the stack.
+         */
+        static forAccount(scope) {
+            const stack = core_1.Stack.of(scope);
+            const existing = stack.node.tryFindChild(ACCOUNT_CATALOG_UID);
+            return existing ?? new AccountCatalog(stack, ACCOUNT_CATALOG_UID, {});
+        }
+        /**
+         * Configure Data Catalog encryption for the implicit, account-wide catalog and
+         * return it.
+         *
+         * The account catalog's encryption is an account/region-wide setting, managed
+         * through the singleton `PutDataCatalogEncryptionSettings` API. Because
+         * encryption is fixed at construction, it must be configured before the
+         * account catalog is first used in the stack: calling this after the account
+         * catalog has already been materialized (for example by `Catalog.forAccount`,
+         * or by a `Database` that uses the account catalog) throws.
+         *
+         * Configure it in exactly one stack. Configuring it from multiple stacks in the
+         * same account and region makes those stacks overwrite one another at deploy
+         * time, and the result is order-dependent. Unlike duplicate settings within a
+         * single stack (which CloudFormation rejects), this cross-stack conflict is not
+         * caught at synthesis time, because each stack synthesizes to its own template.
+         */
+        static encryptAccount(scope, options) {
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_glue_alpha_CatalogEncryptionOptions(options);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, this.encryptAccount);
+                }
+                throw error;
+            }
+            const stack = core_1.Stack.of(scope);
+            if (stack.node.tryFindChild(ACCOUNT_CATALOG_UID)) {
+                throw new core_1.ValidationError((0, helpers_internal_1.lit) `AccountCatalogAlreadyInUse`, 'the account catalog has already been used in this stack; call Catalog.encryptAccount() before Catalog.forAccount() or any Database that uses the account catalog', scope);
+            }
+            return new AccountCatalog(stack, ACCOUNT_CATALOG_UID, options);
+        }
+        /**
+         * Import an existing catalog by its ARN.
+         *
+         * The ARN must be a Glue catalog ARN, either the account-wide catalog
+         * (`arn:aws:glue:<region>:<account>:catalog`, whose id is the account) or a
+         * named catalog (`arn:aws:glue:<region>:<account>:catalog/<name>`, whose id is
+         * the name).
+         *
+         * The imported catalog is a pure identity handle and does not manage the
+         * catalog's encryption. To manage an existing catalog's Data Catalog
+         * encryption, add a `CfnDataCatalogEncryptionSettings` resource targeting its
+         * id.
+         */
+        static fromCatalogArn(scope, id, catalogArn) {
+            const stack = core_1.Stack.of(scope);
+            const arn = stack.splitArn(catalogArn, core_1.ArnFormat.SLASH_RESOURCE_NAME);
+            // Only validate the shape of concrete ARNs; a tokenized ARN can't be
+            // inspected at synth time, so we trust it.
+            if (!core_1.Token.isUnresolved(catalogArn) && (arn.service !== 'glue' || arn.resource !== 'catalog')) {
+                throw new core_1.ValidationError((0, helpers_internal_1.lit) `InvalidCatalogArn`, `expected a Glue catalog ARN (arn:<partition>:glue:<region>:<account>:catalog[/<name>]), got ${JSON.stringify(catalogArn)}`, scope);
+            }
+            // The account-wide catalog's ARN has no resource name; its id is the
+            // account from the ARN itself (falling back to the stack account for a
+            // tokenized ARN with no parseable account).
+            const catalogId = arn.resourceName ?? arn.account ?? stack.account;
+            return new ImportedCatalog(scope, id, catalogId, catalogArn);
+        }
+        /**
+         * Import an existing catalog by its id.
+         *
+         * The imported catalog is a pure identity handle and does not manage the
+         * catalog's encryption. To manage an existing catalog's Data Catalog
+         * encryption, add a `CfnDataCatalogEncryptionSettings` resource targeting its
+         * id.
+         */
+        static fromCatalogId(scope, id, catalogId) {
+            const stack = core_1.Stack.of(scope);
+            const catalogArn = stack.formatArn({ service: 'glue', resource: 'catalog', resourceName: catalogId });
+            return new ImportedCatalog(scope, id, catalogId, catalogArn);
+        }
+        catalogId;
+        catalogArn;
+        resource;
+        constructor(scope, id, props) {
+            super(scope, id);
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_glue_alpha_CatalogProps(props);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, Catalog);
+                }
+                throw error;
+            }
+            // Enhanced CDK Analytics Telemetry
+            (0, metadata_resource_1.addConstructMetadata)(this, props);
+            this.resource = new aws_glue_1.CfnCatalog(this, 'Resource', {
+                name: props.catalogName,
+                description: props.description,
+            });
+            this.catalogId = this.resource.attrCatalogId;
+            this.catalogArn = this.resource.attrResourceArn;
+            this.configureEncryption(props);
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return Catalog = _classThis;
+})();
+exports.Catalog = Catalog;
+/**
+ * The implicit, account-wide Data Catalog. Not a CloudFormation resource; only
+ * the encryption settings it carries are synthesized.
+ */
+let AccountCatalog = (() => {
+    let _classDecorators = [prop_injectable_1.propertyInjectable];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = CatalogBase;
+    var AccountCatalog = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            AccountCatalog = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        /** Uniquely identifies this class. */
+        static PROPERTY_INJECTION_ID = '@aws-cdk.aws-glue-alpha.AccountCatalog';
+        catalogId;
+        catalogArn;
+        constructor(scope, id, encryption) {
+            super(scope, id);
+            // Enhanced CDK Analytics Telemetry
+            (0, metadata_resource_1.addConstructMetadata)(this, encryption);
+            const stack = core_1.Stack.of(this);
+            this.catalogId = stack.account;
+            // The account catalog's id is implicitly the account id, so the ARN has no resource name.
+            this.catalogArn = stack.formatArn({ service: 'glue', resource: 'catalog' });
+            this.configureEncryption(encryption);
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return AccountCatalog = _classThis;
+})();
+/**
+ * An imported catalog. A pure identity handle: it emits no resources and does
+ * not manage the imported catalog's encryption.
+ */
+let ImportedCatalog = (() => {
+    let _classDecorators = [prop_injectable_1.propertyInjectable];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = CatalogBase;
+    var ImportedCatalog = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ImportedCatalog = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        /** Uniquely identifies this class. */
+        static PROPERTY_INJECTION_ID = '@aws-cdk.aws-glue-alpha.ImportedCatalog';
+        catalogId;
+        catalogArn;
+        constructor(scope, id, catalogId, catalogArn) {
+            super(scope, id);
+            // Enhanced CDK Analytics Telemetry
+            (0, metadata_resource_1.addConstructMetadata)(this, catalogId);
+            this.catalogId = catalogId;
+            this.catalogArn = catalogArn;
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return ImportedCatalog = _classThis;
+})();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"catalog.js","sourceRoot":"","sources":["catalog.ts"],"names":[],"mappings":"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","sourcesContent":["import type { CatalogReference, ICatalogRef } from 'aws-cdk-lib/aws-glue';\nimport { CfnCatalog, CfnDataCatalogEncryptionSettings } from 'aws-cdk-lib/aws-glue';\nimport type * as iam from 'aws-cdk-lib/aws-iam';\nimport type * as kms from 'aws-cdk-lib/aws-kms';\nimport { KeyGrants } from 'aws-cdk-lib/aws-kms';\nimport type { IResource } from 'aws-cdk-lib/core';\nimport { ArnFormat, Resource, Stack, Token, ValidationError } from 'aws-cdk-lib/core';\nimport { lit } from 'aws-cdk-lib/core/lib/helpers-internal';\nimport { addConstructMetadata } from 'aws-cdk-lib/core/lib/metadata-resource';\nimport { propertyInjectable } from 'aws-cdk-lib/core/lib/prop-injectable';\nimport type { Construct } from 'constructs';\n\n/**\n * The encryption-at-rest mode for a Glue Data Catalog.\n *\n * @see https://docs.aws.amazon.com/glue/latest/webapi/API_EncryptionAtRest.html#Glue-Type-EncryptionAtRest-CatalogEncryptionMode\n */\nexport enum CatalogEncryptionMode {\n  /**\n   * Encryption at rest is disabled.\n   */\n  DISABLED = 'DISABLED',\n\n  /**\n   * Server-side encryption (SSE) with an AWS KMS key.\n   */\n  SSE_KMS = 'SSE-KMS',\n\n  /**\n   * Server-side encryption (SSE) with an AWS KMS key, using a service role that\n   * AWS Glue assumes to access the key on your behalf.\n   */\n  SSE_KMS_WITH_SERVICE_ROLE = 'SSE-KMS-WITH-SERVICE-ROLE',\n}\n\n/**\n * Encryption-at-rest configuration for a Glue Data Catalog.\n *\n * The Data Catalog encryption at rest and the connection password encryption\n * are independent: enabling one does not require the other, and each may use a\n * different KMS key.\n *\n * @see https://docs.aws.amazon.com/glue/latest/webapi/API_EncryptionAtRest.html\n */\nexport class DataCatalogEncryptionAtRest {\n  /**\n   * Disable encryption at rest for the Data Catalog.\n   */\n  public static disabled(): DataCatalogEncryptionAtRest {\n    return new DataCatalogEncryptionAtRest(CatalogEncryptionMode.DISABLED);\n  }\n\n  /**\n   * Encrypt the Data Catalog at rest with an AWS KMS key.\n   *\n   * @param key the KMS key to use. If omitted, an AWS-managed key is used and\n   * the key is not exposed as a grantable resource.\n   */\n  public static kms(key?: kms.IKey): DataCatalogEncryptionAtRest {\n    return new DataCatalogEncryptionAtRest(CatalogEncryptionMode.SSE_KMS, key);\n  }\n\n  /**\n   * Encrypt the Data Catalog at rest with an AWS KMS key, accessed through a\n   * service role that AWS Glue assumes on your behalf.\n   *\n   * When a customer-managed `key` is provided, the `role` is automatically\n   * granted `kms:Encrypt`/`kms:Decrypt`/`kms:GenerateDataKey*` on it.\n   *\n   * @param role the service role that AWS Glue assumes to access the key.\n   * @param key the KMS key to use. If omitted, an AWS-managed key is used and\n   * the key is not exposed as a grantable resource.\n   */\n  public static kmsWithServiceRole(role: iam.IRole, key?: kms.IKey): DataCatalogEncryptionAtRest {\n    return new DataCatalogEncryptionAtRest(CatalogEncryptionMode.SSE_KMS_WITH_SERVICE_ROLE, key, role);\n  }\n\n  /**\n   * The encryption mode.\n   */\n  public readonly mode: CatalogEncryptionMode;\n\n  /**\n   * The customer-managed KMS key used for encryption at rest, if any.\n   */\n  public readonly kmsKey?: kms.IKeyRef;\n\n  /**\n   * The service role that AWS Glue assumes to access the KMS key, if any.\n   */\n  public readonly serviceRole?: iam.IRole;\n\n  private constructor(mode: CatalogEncryptionMode, kmsKey?: kms.IKeyRef, serviceRole?: iam.IRole) {\n    this.mode = mode;\n    this.kmsKey = kmsKey;\n    this.serviceRole = serviceRole;\n  }\n}\n\n/**\n * Connection-password encryption configuration for a Glue Data Catalog.\n *\n * When enabled, the Data Catalog encrypts the password as part of\n * `CreateConnection` or `UpdateConnection` and stores it in the\n * `ENCRYPTED_PASSWORD` field of the connection properties. This is independent\n * from catalog encryption at rest, and may use a different KMS key.\n *\n * @see https://docs.aws.amazon.com/glue/latest/webapi/API_ConnectionPasswordEncryption.html\n */\nexport interface ConnectionPasswordEncryption {\n  /**\n   * The KMS key used to encrypt connection passwords.\n   *\n   * @default - an AWS-managed key is used and the key is not exposed as a grantable resource.\n   */\n  readonly kmsKey?: kms.IKeyRef;\n\n  /**\n   * Whether passwords remain encrypted in the responses of `GetConnection` and\n   * `GetConnections`. This takes effect independently from catalog encryption.\n   *\n   * @default true\n   */\n  readonly returnConnectionPasswordEncrypted?: boolean;\n}\n\n/**\n * Encryption configuration for a Glue Data Catalog.\n *\n * Encryption is fixed at construction: a catalog either carries encryption\n * settings or it does not, which keeps its configuration easy to reason about\n * and avoids order-dependent mutation after the catalog is created.\n */\nexport interface CatalogEncryptionOptions {\n  /**\n   * Encryption-at-rest configuration for the catalog.\n   *\n   * @default - encryption at rest is not managed by CDK (the catalog default applies)\n   */\n  readonly encryptionAtRest?: DataCatalogEncryptionAtRest;\n\n  /**\n   * Connection-password encryption configuration for the catalog.\n   *\n   * @default - connection-password encryption is not managed by CDK\n   */\n  readonly connectionPasswordEncryption?: ConnectionPasswordEncryption;\n}\n\n/**\n * A Glue Data Catalog, either the implicit account-wide catalog or one created\n * as an `AWS::Glue::Catalog` resource.\n */\nexport interface ICatalog extends IResource, ICatalogRef {\n  /**\n   * The id of the catalog (for the account-wide catalog, the AWS account id).\n   * @attribute\n   */\n  readonly catalogId: string;\n\n  /**\n   * The ARN of the catalog.\n   * @attribute\n   */\n  readonly catalogArn: string;\n\n  /**\n   * The customer-managed KMS key used for the catalog's encryption at rest, if\n   * one was configured.\n   *\n   * Undefined when encryption is disabled or an AWS-managed key is used. Grant\n   * access to it via `KeyGrants`, e.g.\n   * `if (catalog.encryptionKey) { KeyGrants.fromKey(catalog.encryptionKey).encrypt(grantee); }`.\n   */\n  readonly encryptionKey?: kms.IKeyRef;\n\n  /**\n   * The customer-managed KMS key used to encrypt connection passwords, if one\n   * was configured.\n   *\n   * Undefined when password encryption uses an AWS-managed key or is not\n   * configured. Grant access to it via `KeyGrants`, e.g.\n   * `if (catalog.connectionPasswordKey) { KeyGrants.fromKey(catalog.connectionPasswordKey).encrypt(grantee); }`.\n   */\n  readonly connectionPasswordKey?: kms.IKeyRef;\n}\n\n/**\n * Base class for all `ICatalog` implementations. Materializes the single\n * `CfnDataCatalogEncryptionSettings` resource (targeting its own `catalogId`)\n * from the encryption options supplied at construction. Encryption is fixed at\n * construction, so a catalog either carries settings or it does not.\n */\nexport abstract class CatalogBase extends Resource implements ICatalog {\n  public abstract readonly catalogId: string;\n  public abstract readonly catalogArn: string;\n\n  private _encryptionKey?: kms.IKeyRef;\n  private _connectionPasswordKey?: kms.IKeyRef;\n\n  public get encryptionKey(): kms.IKeyRef | undefined {\n    return this._encryptionKey;\n  }\n\n  public get connectionPasswordKey(): kms.IKeyRef | undefined {\n    return this._connectionPasswordKey;\n  }\n\n  public get catalogRef(): CatalogReference {\n    return {\n      resourceArn: this.catalogArn,\n    };\n  }\n\n  /**\n   * Emit the catalog's encryption settings from the options fixed at\n   * construction. Subclasses call this once, after `catalogId`/`catalogArn` are\n   * assigned. When neither block is configured, no resource is emitted, avoiding\n   * an empty settings resource that would reset the catalog on deploy.\n   */\n  protected configureEncryption(options: CatalogEncryptionOptions): void {\n    const atRest = options.encryptionAtRest;\n    const password = options.connectionPasswordEncryption;\n\n    if (!atRest && !password) {\n      return;\n    }\n\n    this._encryptionKey = atRest?.kmsKey;\n    this._connectionPasswordKey = password?.kmsKey;\n\n    // Auto-grant the service role access to the customer-managed key it needs\n    // to encrypt and decrypt catalog data. Nothing to grant for an AWS-managed\n    // key (we don't own its key policy).\n    if (atRest?.serviceRole && atRest.kmsKey) {\n      KeyGrants.fromKey(atRest.kmsKey).encryptDecrypt(atRest.serviceRole);\n    }\n\n    // Two catalog instances that target the same catalog id would each emit a\n    // settings resource and race to overwrite one another via\n    // `PutDataCatalogEncryptionSettings`. Within one stack this is surfaced by\n    // CloudFormation template validation (E3019: duplicate primary identifiers),\n    // so we do not duplicate that check here.\n    new CfnDataCatalogEncryptionSettings(this, 'EncryptionSettings', {\n      catalogId: this.catalogId,\n      dataCatalogEncryptionSettings: {\n        encryptionAtRest: atRest\n          ? {\n            catalogEncryptionMode: atRest.mode,\n            sseAwsKmsKeyId: atRest.kmsKey?.keyRef.keyArn,\n            catalogEncryptionServiceRole: atRest.serviceRole?.roleArn,\n          }\n          : undefined,\n        connectionPasswordEncryption: password\n          ? {\n            kmsKeyId: password.kmsKey?.keyRef.keyArn,\n            returnConnectionPasswordEncrypted: password.returnConnectionPasswordEncrypted ?? true,\n          }\n          : undefined,\n      },\n    });\n  }\n}\n\n/**\n * Construction properties for a `Catalog`.\n */\nexport interface CatalogProps extends CatalogEncryptionOptions {\n  /**\n   * The name of the catalog.\n   */\n  readonly catalogName: string;\n\n  /**\n   * A description of the catalog.\n   *\n   * @default - no description\n   */\n  readonly description?: string;\n}\n\n/**\n * The stack-scoped singleton id for the implicit account-wide catalog.\n */\nconst ACCOUNT_CATALOG_UID = '@aws-cdk.aws-glue-alpha.AccountCatalog';\n\n/**\n * A Glue Data Catalog.\n *\n * Use `Catalog.forAccount(scope)` to obtain the implicit account-wide catalog,\n * `Catalog.encryptAccount(scope, options)` to configure its Data Catalog\n * encryption, or `new Catalog(...)` to create an `AWS::Glue::Catalog` resource.\n */\n@propertyInjectable\nexport class Catalog extends CatalogBase {\n  /** Uniquely identifies this class. */\n  public static readonly PROPERTY_INJECTION_ID: string = '@aws-cdk.aws-glue-alpha.Catalog';\n\n  /**\n   * Obtain the implicit, account-wide Data Catalog.\n   *\n   * The account catalog is not a CloudFormation resource; it always exists. This\n   * returns a stack-scoped singleton, so repeated calls within the same stack\n   * return the same instance.\n   *\n   * This returns the account catalog without managing its encryption. To\n   * configure Data Catalog encryption for the account, use\n   * `Catalog.encryptAccount(scope, options)` instead - it must be called before\n   * the account catalog is first used in the stack.\n   */\n  public static forAccount(scope: Construct): ICatalog {\n    const stack = Stack.of(scope);\n    const existing = stack.node.tryFindChild(ACCOUNT_CATALOG_UID);\n    return (existing as AccountCatalog) ?? new AccountCatalog(stack, ACCOUNT_CATALOG_UID, {});\n  }\n\n  /**\n   * Configure Data Catalog encryption for the implicit, account-wide catalog and\n   * return it.\n   *\n   * The account catalog's encryption is an account/region-wide setting, managed\n   * through the singleton `PutDataCatalogEncryptionSettings` API. Because\n   * encryption is fixed at construction, it must be configured before the\n   * account catalog is first used in the stack: calling this after the account\n   * catalog has already been materialized (for example by `Catalog.forAccount`,\n   * or by a `Database` that uses the account catalog) throws.\n   *\n   * Configure it in exactly one stack. Configuring it from multiple stacks in the\n   * same account and region makes those stacks overwrite one another at deploy\n   * time, and the result is order-dependent. Unlike duplicate settings within a\n   * single stack (which CloudFormation rejects), this cross-stack conflict is not\n   * caught at synthesis time, because each stack synthesizes to its own template.\n   */\n  public static encryptAccount(scope: Construct, options: CatalogEncryptionOptions): ICatalog {\n    const stack = Stack.of(scope);\n    if (stack.node.tryFindChild(ACCOUNT_CATALOG_UID)) {\n      throw new ValidationError(\n        lit`AccountCatalogAlreadyInUse`,\n        'the account catalog has already been used in this stack; call Catalog.encryptAccount() before Catalog.forAccount() or any Database that uses the account catalog',\n        scope,\n      );\n    }\n    return new AccountCatalog(stack, ACCOUNT_CATALOG_UID, options);\n  }\n\n  /**\n   * Import an existing catalog by its ARN.\n   *\n   * The ARN must be a Glue catalog ARN, either the account-wide catalog\n   * (`arn:aws:glue:<region>:<account>:catalog`, whose id is the account) or a\n   * named catalog (`arn:aws:glue:<region>:<account>:catalog/<name>`, whose id is\n   * the name).\n   *\n   * The imported catalog is a pure identity handle and does not manage the\n   * catalog's encryption. To manage an existing catalog's Data Catalog\n   * encryption, add a `CfnDataCatalogEncryptionSettings` resource targeting its\n   * id.\n   */\n  public static fromCatalogArn(scope: Construct, id: string, catalogArn: string): ICatalog {\n    const stack = Stack.of(scope);\n    const arn = stack.splitArn(catalogArn, ArnFormat.SLASH_RESOURCE_NAME);\n\n    // Only validate the shape of concrete ARNs; a tokenized ARN can't be\n    // inspected at synth time, so we trust it.\n    if (!Token.isUnresolved(catalogArn) && (arn.service !== 'glue' || arn.resource !== 'catalog')) {\n      throw new ValidationError(\n        lit`InvalidCatalogArn`,\n        `expected a Glue catalog ARN (arn:<partition>:glue:<region>:<account>:catalog[/<name>]), got ${JSON.stringify(catalogArn)}`,\n        scope,\n      );\n    }\n\n    // The account-wide catalog's ARN has no resource name; its id is the\n    // account from the ARN itself (falling back to the stack account for a\n    // tokenized ARN with no parseable account).\n    const catalogId = arn.resourceName ?? arn.account ?? stack.account;\n    return new ImportedCatalog(scope, id, catalogId, catalogArn);\n  }\n\n  /**\n   * Import an existing catalog by its id.\n   *\n   * The imported catalog is a pure identity handle and does not manage the\n   * catalog's encryption. To manage an existing catalog's Data Catalog\n   * encryption, add a `CfnDataCatalogEncryptionSettings` resource targeting its\n   * id.\n   */\n  public static fromCatalogId(scope: Construct, id: string, catalogId: string): ICatalog {\n    const stack = Stack.of(scope);\n    const catalogArn = stack.formatArn({ service: 'glue', resource: 'catalog', resourceName: catalogId });\n    return new ImportedCatalog(scope, id, catalogId, catalogArn);\n  }\n\n  public readonly catalogId: string;\n  public readonly catalogArn: string;\n\n  private readonly resource: CfnCatalog;\n\n  constructor(scope: Construct, id: string, props: CatalogProps) {\n    super(scope, id);\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, props);\n\n    this.resource = new CfnCatalog(this, 'Resource', {\n      name: props.catalogName,\n      description: props.description,\n    });\n\n    this.catalogId = this.resource.attrCatalogId;\n    this.catalogArn = this.resource.attrResourceArn;\n\n    this.configureEncryption(props);\n  }\n}\n\n/**\n * The implicit, account-wide Data Catalog. Not a CloudFormation resource; only\n * the encryption settings it carries are synthesized.\n */\n@propertyInjectable\nclass AccountCatalog extends CatalogBase {\n  /** Uniquely identifies this class. */\n  public static readonly PROPERTY_INJECTION_ID: string = '@aws-cdk.aws-glue-alpha.AccountCatalog';\n  public readonly catalogId: string;\n  public readonly catalogArn: string;\n\n  constructor(scope: Construct, id: string, encryption: CatalogEncryptionOptions) {\n    super(scope, id);\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, encryption);\n    const stack = Stack.of(this);\n    this.catalogId = stack.account;\n    // The account catalog's id is implicitly the account id, so the ARN has no resource name.\n    this.catalogArn = stack.formatArn({ service: 'glue', resource: 'catalog' });\n\n    this.configureEncryption(encryption);\n  }\n}\n\n/**\n * An imported catalog. A pure identity handle: it emits no resources and does\n * not manage the imported catalog's encryption.\n */\n@propertyInjectable\nclass ImportedCatalog extends CatalogBase {\n  /** Uniquely identifies this class. */\n  public static readonly PROPERTY_INJECTION_ID: string = '@aws-cdk.aws-glue-alpha.ImportedCatalog';\n  public readonly catalogId: string;\n  public readonly catalogArn: string;\n\n  constructor(scope: Construct, id: string, catalogId: string, catalogArn: string) {\n    super(scope, id);\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, catalogId);\n    this.catalogId = catalogId;\n    this.catalogArn = catalogArn;\n  }\n}\n"]}

package/lib/code.js

@@ -43,7 +43,7 @@ const helpers_internal_1 = require("aws-cdk-lib/core/lib/helpers-internal");
  * Represents a Glue Job's Code assets (an asset can be a scripts, a jar, a python file or any other file).
  */
 class Code {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-glue-alpha.Code", version: "2.263.0-alpha.0" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-glue-alpha.Code", version: "2.265.0-alpha.0" };
     /**
      * Job code as an S3 object.
      * @param bucket The S3 bucket
@@ -68,7 +68,7 @@ exports.Code = Code;
 class S3Code extends Code {
     bucket;
     key;
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-glue-alpha.S3Code", version: "2.263.0-alpha.0" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-glue-alpha.S3Code", version: "2.265.0-alpha.0" };
     constructor(bucket, key) {
         super();
         this.bucket = bucket;
@@ -91,7 +91,7 @@ exports.S3Code = S3Code;
 class AssetCode extends Code {
     path;
     options;
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-glue-alpha.AssetCode", version: "2.263.0-alpha.0" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-glue-alpha.AssetCode", version: "2.265.0-alpha.0" };
     asset;
     /**
      * @param path The path to the Code file.