@aws-cdk/aws-glue-alpha 2.268.0-alpha.0 → 2.270.0-alpha.0

package/lib/external-table.js

@@ -77,7 +77,7 @@ let ExternalTable = (() => {
             ExternalTable = _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.ExternalTable", version: "2.268.0-alpha.0" };
+        static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-glue-alpha.ExternalTable", version: "2.270.0-alpha.0" };
         /** Uniquely identifies this class. */
         static PROPERTY_INJECTION_ID = '@aws-cdk.aws-glue-alpha.ExternalTable';
         /**
@@ -93,6 +93,7 @@ let ExternalTable = (() => {
         constructor(scope, id, props) {
             super(scope, id, props);
             try {
+                jsiiDeprecationWarnings.print("@aws-cdk/aws-glue-alpha.ExternalTable", "");
                 jsiiDeprecationWarnings._aws_cdk_aws_glue_alpha_ExternalTableProps(props);
             }
             catch (error) {
@@ -154,12 +155,30 @@ let ExternalTable = (() => {
          * Name of this table.
          */
         get tableName() {
+            try {
+                jsiiDeprecationWarnings.print("@aws-cdk/aws-glue-alpha.ExternalTable#tableName", "");
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, jsiiDeprecationWarnings.getPropertyDescriptor(this, "tableName").get);
+                }
+                throw error;
+            }
             return this.getResourceNameAttribute(this.resource.ref);
         }
         /**
          * ARN of this table.
          */
         get tableArn() {
+            try {
+                jsiiDeprecationWarnings.print("@aws-cdk/aws-glue-alpha.ExternalTable#tableArn", "");
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, jsiiDeprecationWarnings.getPropertyDescriptor(this, "tableArn").get);
+                }
+                throw error;
+            }
             return this.stack.formatArn({
                 service: 'glue',
                 resource: 'table',
@@ -173,6 +192,15 @@ let ExternalTable = (() => {
          * @param grantee the principal
          */
         grantRead(grantee) {
+            try {
+                jsiiDeprecationWarnings.print("@aws-cdk/aws-glue-alpha.ExternalTable#grantRead", "");
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, this.grantRead);
+                }
+                throw error;
+            }
             const ret = this.grant(grantee, readPermissions);
             return ret;
         }
@@ -183,6 +211,15 @@ let ExternalTable = (() => {
          * @param grantee the principal
          */
         grantWrite(grantee) {
+            try {
+                jsiiDeprecationWarnings.print("@aws-cdk/aws-glue-alpha.ExternalTable#grantWrite", "");
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, this.grantWrite);
+                }
+                throw error;
+            }
             const ret = this.grant(grantee, writePermissions);
             return ret;
         }
@@ -193,6 +230,15 @@ let ExternalTable = (() => {
          * @param grantee the principal
          */
         grantReadWrite(grantee) {
+            try {
+                jsiiDeprecationWarnings.print("@aws-cdk/aws-glue-alpha.ExternalTable#grantReadWrite", "");
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, this.grantReadWrite);
+                }
+                throw error;
+            }
             const ret = this.grant(grantee, [...readPermissions, ...writePermissions]);
             return ret;
         }
@@ -231,4 +277,4 @@ function renderColumns(columns) {
         };
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"external-table.js","sourceRoot":"","sources":["external-table.ts"],"names":[],"mappings":"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","sourcesContent":["import { ValidationError } from 'aws-cdk-lib';\nimport { CfnTable } from 'aws-cdk-lib/aws-glue';\nimport type * as iam from 'aws-cdk-lib/aws-iam';\nimport { memoizedGetter, lit } from 'aws-cdk-lib/core/lib/helpers-internal';\nimport { addConstructMetadata, MethodMetadata } from 'aws-cdk-lib/core/lib/metadata-resource';\nimport { propertyInjectable } from 'aws-cdk-lib/core/lib/prop-injectable';\nimport type { Construct } from 'constructs';\nimport type { IConnection } from './connection';\nimport type { Column } from './schema';\nimport type { PartitionIndex, TableBaseProps } from './table-base';\nimport { TableBase } from './table-base';\n\nexport interface ExternalTableProps extends TableBaseProps {\n  /**\n   * The connection the table will use when performing reads and writes.\n   *\n   * @default - No connection\n   */\n  readonly connection: IConnection;\n\n  /**\n   * The data source location of the glue table, (e.g. `default_db_public_example` for Redshift).\n   *\n   * If this property is set, it will override both `bucket` and `s3Prefix`.\n   *\n   * @default - No outsourced data source location\n   */\n  readonly externalDataLocation: string;\n}\n\n/**\n * A Glue table that targets an external data location (e.g. A table in a Redshift Cluster).\n * @resource AWS::Glue::Table\n */\n@propertyInjectable\nexport class ExternalTable extends TableBase {\n  /** Uniquely identifies this class. */\n  public static readonly PROPERTY_INJECTION_ID: string = '@aws-cdk.aws-glue-alpha.ExternalTable';\n\n  /**\n   * The connection associated to this table\n   */\n  public readonly connection: IConnection;\n\n  /**\n   * This table's partition indexes.\n   */\n  public readonly partitionIndexes?: PartitionIndex[];\n\n  protected readonly tableResource: CfnTable;\n\n  private resource: CfnTable;\n\n  constructor(scope: Construct, id: string, props: ExternalTableProps) {\n    super(scope, id, props);\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, props);\n    this.connection = props.connection;\n    this.resource = new CfnTable(this, 'Table', {\n      catalogId: props.database.catalog.catalogId,\n\n      databaseName: props.database.databaseName,\n\n      tableInput: {\n        name: this.physicalName,\n        description: props.description || `${this.physicalName} generated by CDK`,\n\n        partitionKeys: renderColumns(props.partitionKeys),\n\n        parameters: {\n          'classification': props.dataFormat.classificationString?.value,\n          'partition_filtering.enabled': props.enablePartitionFiltering,\n          'connectionName': props.connection.connectionName,\n          ...this.parameters,\n          // Managed keys are emitted last so free-form `parameters` cannot\n          // silently override them. Conflicts are rejected in `TableBase`.\n          'has_encrypted_data': this.hasEncryptedData,\n        },\n        storageDescriptor: {\n          location: props.externalDataLocation,\n          compressed: this.compressed,\n          storedAsSubDirectories: props.storedAsSubDirectories ?? false,\n          columns: renderColumns(props.columns),\n          inputFormat: props.dataFormat.inputFormat.className,\n          outputFormat: props.dataFormat.outputFormat.className,\n          serdeInfo: {\n            serializationLibrary: props.dataFormat.serializationLibrary.className,\n          },\n          parameters: props.storageParameters ? props.storageParameters.reduce((acc, param) => {\n            if (param.key in acc) {\n              throw new ValidationError(lit`DuplicateStorageParameterKey`, `Duplicate storage parameter key: ${param.key}`, this);\n            }\n            const key = param.key;\n            acc[key] = param.value;\n            return acc;\n          }, {} as { [key: string]: string }) : undefined,\n        },\n\n        tableType: 'EXTERNAL_TABLE',\n      },\n    });\n\n    this.tableResource = this.resource;\n    this.node.defaultChild = this.resource;\n\n    // Partition index creation relies on created table.\n    if (props.partitionIndexes) {\n      this.partitionIndexes = props.partitionIndexes;\n      this.partitionIndexes.forEach((index) => this.addPartitionIndex(index));\n    }\n  }\n\n  /**\n   * Name of this table.\n   */\n  @memoizedGetter\n  public get tableName(): string {\n    return this.getResourceNameAttribute(this.resource.ref);\n  }\n\n  /**\n   * ARN of this table.\n   */\n  @memoizedGetter\n  public get tableArn(): string {\n    return this.stack.formatArn({\n      service: 'glue',\n      resource: 'table',\n      resourceName: `${this.database.databaseName}/${this.tableName}`,\n    });\n  }\n\n  /**\n   * Grant read permissions to the table\n   * [disable-awslint:no-grants]\n   *\n   * @param grantee the principal\n   */\n  @MethodMetadata()\n  public grantRead(grantee: iam.IGrantable): iam.Grant {\n    const ret = this.grant(grantee, readPermissions);\n    return ret;\n  }\n\n  /**\n   * Grant write permissions to the table\n   * [disable-awslint:no-grants]\n   *\n   * @param grantee the principal\n   */\n  @MethodMetadata()\n  public grantWrite(grantee: iam.IGrantable): iam.Grant {\n    const ret = this.grant(grantee, writePermissions);\n    return ret;\n  }\n\n  /**\n   * Grant read and write permissions to the table\n   * [disable-awslint:no-grants]\n   *\n   * @param grantee the principal\n   */\n  @MethodMetadata()\n  public grantReadWrite(grantee: iam.IGrantable): iam.Grant {\n    const ret = this.grant(grantee, [...readPermissions, ...writePermissions]);\n    return ret;\n  }\n}\n\nconst readPermissions = [\n  'glue:BatchGetPartition',\n  'glue:GetPartition',\n  'glue:GetPartitions',\n  'glue:GetTable',\n  'glue:GetTables',\n  'glue:GetTableVersion',\n  'glue:GetTableVersions',\n];\n\nconst writePermissions = [\n  'glue:BatchCreatePartition',\n  'glue:BatchDeletePartition',\n  'glue:CreatePartition',\n  'glue:DeletePartition',\n  'glue:UpdatePartition',\n];\n\nfunction renderColumns(columns?: Column[]) {\n  if (columns === undefined) {\n    return undefined;\n  }\n  return columns.map(column => {\n    return {\n      name: column.name,\n      type: column.type.inputString,\n      comment: column.comment,\n    };\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"external-table.js","sourceRoot":"","sources":["external-table.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6CAA8C;AAC9C,mDAAgD;AAEhD,4EAA4E;AAC5E,8EAA8F;AAC9F,0EAA0E;AAK1E,6CAAyC;AAoBzC;;;GAGG;IAEU,aAAa;4BADzB,oCAAkB;;;;sBACgB,sBAAS;;;;;;;6BAAjB,SAAQ,WAAS;;;;yCAgFzC,iCAAc;wCAQd,iCAAc;qCAed,IAAA,kCAAc,GAAE;sCAYhB,IAAA,kCAAc,GAAE;0CAYhB,IAAA,kCAAc,GAAE;YA9CjB,kLAAW,SAAS,6DAEnB;YAMD,+KAAW,QAAQ,6DAMlB;YASD,8KAAO,SAAS,6DAGf;YASD,iLAAO,UAAU,6DAGhB;YASD,6LAAO,cAAc,6DAGpB;YAnIH,6KAoIC;;;;;QAnIC,sCAAsC;QAC/B,MAAM,CAAU,qBAAqB,GAAW,uCAAuC,CAAC;QAE/F;;WAEG;QACa,UAAU,GAPf,mDAAa,CAOgB;QAExC;;WAEG;QACa,gBAAgB,CAAoB;QAEjC,aAAa,CAAW;QAEnC,QAAQ,CAAW;QAE3B,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAyB;YACjE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;;;;;;;mDAnBf,aAAa;;;;YAoBtB,mCAAmC;YACnC,IAAA,wCAAoB,EAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YAClC,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,CAAC;YACnC,IAAI,CAAC,QAAQ,GAAG,IAAI,mBAAQ,CAAC,IAAI,EAAE,OAAO,EAAE;gBAC1C,SAAS,EAAE,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,SAAS;gBAE3C,YAAY,EAAE,KAAK,CAAC,QAAQ,CAAC,YAAY;gBAEzC,UAAU,EAAE;oBACV,IAAI,EAAE,IAAI,CAAC,YAAY;oBACvB,WAAW,EAAE,KAAK,CAAC,WAAW,IAAI,GAAG,IAAI,CAAC,YAAY,mBAAmB;oBAEzE,aAAa,EAAE,aAAa,CAAC,KAAK,CAAC,aAAa,CAAC;oBAEjD,UAAU,EAAE;wBACV,gBAAgB,EAAE,KAAK,CAAC,UAAU,CAAC,oBAAoB,EAAE,KAAK;wBAC9D,6BAA6B,EAAE,KAAK,CAAC,wBAAwB;wBAC7D,gBAAgB,EAAE,KAAK,CAAC,UAAU,CAAC,cAAc;wBACjD,GAAG,IAAI,CAAC,UAAU;wBAClB,iEAAiE;wBACjE,iEAAiE;wBACjE,oBAAoB,EAAE,IAAI,CAAC,gBAAgB;qBAC5C;oBACD,iBAAiB,EAAE;wBACjB,QAAQ,EAAE,KAAK,CAAC,oBAAoB;wBACpC,UAAU,EAAE,IAAI,CAAC,UAAU;wBAC3B,sBAAsB,EAAE,KAAK,CAAC,sBAAsB,IAAI,KAAK;wBAC7D,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,OAAO,CAAC;wBACrC,WAAW,EAAE,KAAK,CAAC,UAAU,CAAC,WAAW,CAAC,SAAS;wBACnD,YAAY,EAAE,KAAK,CAAC,UAAU,CAAC,YAAY,CAAC,SAAS;wBACrD,SAAS,EAAE;4BACT,oBAAoB,EAAE,KAAK,CAAC,UAAU,CAAC,oBAAoB,CAAC,SAAS;yBACtE;wBACD,UAAU,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE;4BAClF,IAAI,KAAK,CAAC,GAAG,IAAI,GAAG,EAAE,CAAC;gCACrB,MAAM,IAAI,6BAAe,CAAC,IAAA,sBAAG,EAAA,8BAA8B,EAAE,oCAAoC,KAAK,CAAC,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;4BACtH,CAAC;4BACD,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC;4BACtB,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;4BACvB,OAAO,GAAG,CAAC;wBACb,CAAC,EAAE,EAA+B,CAAC,CAAC,CAAC,CAAC,SAAS;qBAChD;oBAED,SAAS,EAAE,gBAAgB;iBAC5B;aACF,CAAC,CAAC;YAEH,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,QAAQ,CAAC;YACnC,IAAI,CAAC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC;YAEvC,oDAAoD;YACpD,IAAI,KAAK,CAAC,gBAAgB,EAAE,CAAC;gBAC3B,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC,gBAAgB,CAAC;gBAC/C,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC;YAC1E,CAAC;SACF;QAED;;WAEG;QAEH,IAAW,SAAS;;;;;;;;;;YAClB,OAAO,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;SACzD;QAED;;WAEG;QAEH,IAAW,QAAQ;;;;;;;;;;YACjB,OAAO,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC;gBAC1B,OAAO,EAAE,MAAM;gBACf,QAAQ,EAAE,OAAO;gBACjB,YAAY,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,YAAY,IAAI,IAAI,CAAC,SAAS,EAAE;aAChE,CAAC,CAAC;SACJ;QAED;;;;;WAKG;QAEI,SAAS,CAAC,OAAuB;;;;;;;;;;YACtC,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC;YACjD,OAAO,GAAG,CAAC;SACZ;QAED;;;;;WAKG;QAEI,UAAU,CAAC,OAAuB;;;;;;;;;;YACvC,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC;YAClD,OAAO,GAAG,CAAC;SACZ;QAED;;;;;WAKG;QAEI,cAAc,CAAC,OAAuB;;;;;;;;;;YAC3C,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,GAAG,eAAe,EAAE,GAAG,gBAAgB,CAAC,CAAC,CAAC;YAC3E,OAAO,GAAG,CAAC;SACZ;;YAnIU,uDAAa;;;;;AAAb,sCAAa;AAsI1B,MAAM,eAAe,GAAG;IACtB,wBAAwB;IACxB,mBAAmB;IACnB,oBAAoB;IACpB,eAAe;IACf,gBAAgB;IAChB,sBAAsB;IACtB,uBAAuB;CACxB,CAAC;AAEF,MAAM,gBAAgB,GAAG;IACvB,2BAA2B;IAC3B,2BAA2B;IAC3B,sBAAsB;IACtB,sBAAsB;IACtB,sBAAsB;CACvB,CAAC;AAEF,SAAS,aAAa,CAAC,OAAkB;IACvC,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE;QAC1B,OAAO;YACL,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,WAAW;YAC7B,OAAO,EAAE,MAAM,CAAC,OAAO;SACxB,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["import { ValidationError } from 'aws-cdk-lib';\nimport { CfnTable } from 'aws-cdk-lib/aws-glue';\nimport type * as iam from 'aws-cdk-lib/aws-iam';\nimport { memoizedGetter, lit } from 'aws-cdk-lib/core/lib/helpers-internal';\nimport { addConstructMetadata, MethodMetadata } from 'aws-cdk-lib/core/lib/metadata-resource';\nimport { propertyInjectable } from 'aws-cdk-lib/core/lib/prop-injectable';\nimport type { Construct } from 'constructs';\nimport type { IConnection } from './connection';\nimport type { Column } from './schema';\nimport type { PartitionIndex, TableBaseProps } from './table-base';\nimport { TableBase } from './table-base';\n\nexport interface ExternalTableProps extends TableBaseProps {\n  /**\n   * The connection the table will use when performing reads and writes.\n   *\n   * @default - No connection\n   */\n  readonly connection: IConnection;\n\n  /**\n   * The data source location of the glue table, (e.g. `default_db_public_example` for Redshift).\n   *\n   * If this property is set, it will override both `bucket` and `s3Prefix`.\n   *\n   * @default - No outsourced data source location\n   */\n  readonly externalDataLocation: string;\n}\n\n/**\n * A Glue table that targets an external data location (e.g. A table in a Redshift Cluster).\n * @resource AWS::Glue::Table\n */\n@propertyInjectable\nexport class ExternalTable extends TableBase {\n  /** Uniquely identifies this class. */\n  public static readonly PROPERTY_INJECTION_ID: string = '@aws-cdk.aws-glue-alpha.ExternalTable';\n\n  /**\n   * The connection associated to this table\n   */\n  public readonly connection: IConnection;\n\n  /**\n   * This table's partition indexes.\n   */\n  public readonly partitionIndexes?: PartitionIndex[];\n\n  protected readonly tableResource: CfnTable;\n\n  private resource: CfnTable;\n\n  constructor(scope: Construct, id: string, props: ExternalTableProps) {\n    super(scope, id, props);\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, props);\n    this.connection = props.connection;\n    this.resource = new CfnTable(this, 'Table', {\n      catalogId: props.database.catalog.catalogId,\n\n      databaseName: props.database.databaseName,\n\n      tableInput: {\n        name: this.physicalName,\n        description: props.description || `${this.physicalName} generated by CDK`,\n\n        partitionKeys: renderColumns(props.partitionKeys),\n\n        parameters: {\n          'classification': props.dataFormat.classificationString?.value,\n          'partition_filtering.enabled': props.enablePartitionFiltering,\n          'connectionName': props.connection.connectionName,\n          ...this.parameters,\n          // Managed keys are emitted last so free-form `parameters` cannot\n          // silently override them. Conflicts are rejected in `TableBase`.\n          'has_encrypted_data': this.hasEncryptedData,\n        },\n        storageDescriptor: {\n          location: props.externalDataLocation,\n          compressed: this.compressed,\n          storedAsSubDirectories: props.storedAsSubDirectories ?? false,\n          columns: renderColumns(props.columns),\n          inputFormat: props.dataFormat.inputFormat.className,\n          outputFormat: props.dataFormat.outputFormat.className,\n          serdeInfo: {\n            serializationLibrary: props.dataFormat.serializationLibrary.className,\n          },\n          parameters: props.storageParameters ? props.storageParameters.reduce((acc, param) => {\n            if (param.key in acc) {\n              throw new ValidationError(lit`DuplicateStorageParameterKey`, `Duplicate storage parameter key: ${param.key}`, this);\n            }\n            const key = param.key;\n            acc[key] = param.value;\n            return acc;\n          }, {} as { [key: string]: string }) : undefined,\n        },\n\n        tableType: 'EXTERNAL_TABLE',\n      },\n    });\n\n    this.tableResource = this.resource;\n    this.node.defaultChild = this.resource;\n\n    // Partition index creation relies on created table.\n    if (props.partitionIndexes) {\n      this.partitionIndexes = props.partitionIndexes;\n      this.partitionIndexes.forEach((index) => this.addPartitionIndex(index));\n    }\n  }\n\n  /**\n   * Name of this table.\n   */\n  @memoizedGetter\n  public get tableName(): string {\n    return this.getResourceNameAttribute(this.resource.ref);\n  }\n\n  /**\n   * ARN of this table.\n   */\n  @memoizedGetter\n  public get tableArn(): string {\n    return this.stack.formatArn({\n      service: 'glue',\n      resource: 'table',\n      resourceName: `${this.database.databaseName}/${this.tableName}`,\n    });\n  }\n\n  /**\n   * Grant read permissions to the table\n   * [disable-awslint:no-grants]\n   *\n   * @param grantee the principal\n   */\n  @MethodMetadata()\n  public grantRead(grantee: iam.IGrantable): iam.Grant {\n    const ret = this.grant(grantee, readPermissions);\n    return ret;\n  }\n\n  /**\n   * Grant write permissions to the table\n   * [disable-awslint:no-grants]\n   *\n   * @param grantee the principal\n   */\n  @MethodMetadata()\n  public grantWrite(grantee: iam.IGrantable): iam.Grant {\n    const ret = this.grant(grantee, writePermissions);\n    return ret;\n  }\n\n  /**\n   * Grant read and write permissions to the table\n   * [disable-awslint:no-grants]\n   *\n   * @param grantee the principal\n   */\n  @MethodMetadata()\n  public grantReadWrite(grantee: iam.IGrantable): iam.Grant {\n    const ret = this.grant(grantee, [...readPermissions, ...writePermissions]);\n    return ret;\n  }\n}\n\nconst readPermissions = [\n  'glue:BatchGetPartition',\n  'glue:GetPartition',\n  'glue:GetPartitions',\n  'glue:GetTable',\n  'glue:GetTables',\n  'glue:GetTableVersion',\n  'glue:GetTableVersions',\n];\n\nconst writePermissions = [\n  'glue:BatchCreatePartition',\n  'glue:BatchDeletePartition',\n  'glue:CreatePartition',\n  'glue:DeletePartition',\n  'glue:UpdatePartition',\n];\n\nfunction renderColumns(columns?: Column[]) {\n  if (columns === undefined) {\n    return undefined;\n  }\n  return columns.map(column => {\n    return {\n      name: column.name,\n      type: column.type.inputString,\n      comment: column.comment,\n    };\n  });\n}\n"]}

package/lib/jobs/job.d.ts

@@ -1,5 +1,6 @@
 import * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';
 import * as events from 'aws-cdk-lib/aws-events';
+import type { IJobRef, JobReference } from 'aws-cdk-lib/aws-glue';
 import * as iam from 'aws-cdk-lib/aws-iam';
 import type * as logs from 'aws-cdk-lib/aws-logs';
 import * as cdk from 'aws-cdk-lib/core';
@@ -12,7 +13,7 @@ import type { ISecurityConfiguration } from '../security-configuration';
 /**
  * Interface representing a new or an imported Glue Job
  */
-export interface IJob extends cdk.IResource, iam.IGrantable {
+export interface IJob extends cdk.IResource, iam.IGrantable, IJobRef {
     /**
      * The name of the job.
      * @attribute
@@ -119,6 +120,10 @@ export declare abstract class JobBase extends cdk.Resource implements IJob {
     abstract readonly jobArn: string;
     abstract readonly jobName: string;
     abstract readonly grantPrincipal: iam.IPrincipal;
+    /**
+     * A reference to this Job resource, for use with the generated L1 ref interface.
+     */
+    get jobRef(): JobReference;
     /**
      * Create a CloudWatch Event Rule for this Glue Job when it's in a given state
      *
@@ -268,7 +273,16 @@ export interface JobProps {
      * The default arguments for every run of this Glue job,
      * specified as name-value pairs.
      *
-     * These are emitted verbatim into the CloudFormation template, so avoid
+     * This map is the escape hatch for Glue job arguments that this construct does not model. It
+     * MUST NOT be used to set arguments that already have a dedicated prop — configure those through
+     * the corresponding prop instead (`continuousLogging`, `enableMetrics`,
+     * `enableObservabilityMetrics`, `sparkUI`, `className`, `extraJars`, `extraJarsFirst`,
+     * `extraPythonFiles`, `extraFiles`). Passing a construct-managed argument (e.g.
+     * `--enable-continuous-cloudwatch-log`, `--enable-metrics`, `--enable-spark-ui`,
+     * `--job-language`) or a Glue-reserved argument (`--debug`, `--mode`, `--JOB_NAME`, `--endpoint`)
+     * here throws at synthesis time, so there is exactly one way to express each intent.
+     *
+     * Also note that these are emitted verbatim into the CloudFormation template, so avoid
      * placing secrets here in plaintext. Pass secrets to the job at runtime
      * through AWS Secrets Manager instead. A synthesis-time warning is emitted
      * when an argument key looks like a credential and holds a plaintext literal.
@@ -351,26 +365,93 @@ export declare abstract class Job extends JobBase {
      * @param attrs Attributes for the Glue Job we want to import
      */
     static fromJobAttributes(scope: constructs.Construct, id: string, attrs: JobAttributes): IJob;
+    /**
+     * Argument keys that Glue reserves for its own use and that a caller must never set through
+     * `defaultArguments`. Unlike construct-managed arguments (which are derived from what each job
+     * class emits), these are owned by the Glue service itself and are reserved for every job type.
+     *
+     * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
+     */
+    private static readonly GLUE_RESERVED_ARGUMENTS;
     /**
      * The IAM role Glue assumes to run this job.
      */
     abstract readonly role: iam.IRole;
     /**
-     * Check no usage of reserved arguments.
+     * The construct-managed job arguments that are actually emitted for the current configuration,
+     * accumulated via {@link setManagedArgument}. Passed through to `CfnJob.defaultArguments` after
+     * being merged with the user-supplied `defaultArguments` by {@link mergeDefaultArguments}.
+     */
+    private readonly _managedArguments;
+    /**
+     * Every argument key this construct manages, accumulated via {@link setManagedArgument} — whether
+     * or not the current configuration emits a value for it. This is the reserved set that a
+     * user-supplied `defaultArguments` must not collide with. Registering a key even when its value
+     * is `undefined` (feature disabled or unset) is what keeps `defaultArguments` from silently
+     * re-enabling it.
+     */
+    private readonly _managedArgumentKeys;
+    /**
+     * Declare `key` as construct-managed and, when `value` is defined, emit it into the job's
+     * arguments.
      *
+     * This is the single sink for every argument a job construct derives from its typed props (or
+     * from the job class itself). Call it once per managed key, passing `undefined` as the value when
+     * the corresponding feature is turned off or unset — the key is still reserved from
+     * `defaultArguments` either way, so a disabled feature cannot be re-enabled through the escape
+     * hatch. There is deliberately no other way for a subclass to emit a managed argument, so the
+     * reserved set can never drift from what is emitted.
+     *
+     * @param key the Glue argument key, e.g. `--enable-metrics`
+     * @param value the value to emit, or `undefined` to reserve the key without emitting it
+     */
+    protected setManagedArgument(key: string, value?: string): void;
+    /**
+     * Merge the customer-supplied `defaultArguments` with the arguments this construct manages.
+     *
+     * The construct owns every argument it emits — whether the value comes from a dedicated typed
+     * prop (e.g. `continuousLogging`, `enableMetrics`, `sparkUI`) or from the job class itself
+     * (e.g. `--job-language`). Those arguments, plus the arguments Glue reserves for its own use,
+     * MUST be configured through their dedicated props rather than the untyped `defaultArguments`
+     * map, so there is exactly one way to express each intent. Passing such a key through
+     * `defaultArguments` therefore throws instead of silently winning or being silently dropped.
+     *
+     * A managed key whose supplied value is identical to the construct's value is not contradictory,
+     * so it is allowed rather than rejected (auto-correcting config is preferred over errors).
+     * Glue-reserved keys are never emitted by the construct, so there is no value to reconcile and
+     * they always throw.
+     *
+     * The reserved set is `_managedArgumentKeys` — every key the construct declared through
+     * {@link setManagedArgument}, whether or not a value was emitted for it. It is deliberately NOT
+     * derived from the keys that carry a value: a typed prop that turns a feature *off* (e.g.
+     * `enableMetrics: false`) emits no value but still reserves its key, so `defaultArguments` cannot
+     * silently re-enable it.
+     *
+     * Conflict detection relies on string equality of the argument keys, which cannot see through
+     * unresolved tokens (e.g. a key produced by `CfnJson` that only resolves at deploy time). If a
+     * key is a token, the check is skipped for that key and a synthesis-time warning is emitted, so
+     * the (rare) case where a token key resolves to a managed argument at deploy time — in which the
+     * construct-managed value would silently take precedence — is surfaced rather than hidden.
+     *
+     * @param defaultArguments the caller-supplied escape-hatch arguments, if any
      * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
      */
-    protected checkNoReservedArgs(defaultArguments?: {
+    protected mergeDefaultArguments(defaultArguments?: {
         [key: string]: string;
     }): {
         [key: string]: string;
-    } | undefined;
+    };
     /**
-     * Setup Continuous Logging Properties
-     * @param role The IAM role to use for continuous logging
+     * Register (and, when enabled, emit) the continuous-logging arguments this job manages.
+     *
+     * All five continuous-logging keys are reserved on every job type regardless of configuration:
+     * they are always registered through {@link setManagedArgument}, and carry a value only when
+     * logging is enabled. This keeps `defaultArguments` from re-enabling logging a user turned off.
+     *
+     * @param role The IAM role to grant write access to a custom log group, if one is provided
      * @param props The properties for continuous logging configuration
-     * @returns String containing the args for the continuous logging command
+     * @param securityConfiguration The security configuration attached to the job, if any
      */
-    protected setupContinuousLogging(role: iam.IRole, props: ContinuousLoggingProps | undefined): any;
+    protected setupContinuousLogging(role: iam.IRole, props: ContinuousLoggingProps | undefined, securityConfiguration?: ISecurityConfiguration): void;
     protected codeS3ObjectUrl(code: Code): string;
 }