@aws-cdk/aws-glue-alpha 2.176.0-alpha.0 → 2.178.0-alpha.0

package/lib/jobs/scala-spark-flex-etl-job.js

@@ -0,0 +1,143 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScalaSparkFlexEtlJob = void 0;
+const jsiiDeprecationWarnings = require("../../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const iam = require("aws-cdk-lib/aws-iam");
+const aws_s3_1 = require("aws-cdk-lib/aws-s3");
+const aws_glue_1 = require("aws-cdk-lib/aws-glue");
+const job_1 = require("./job");
+const constants_1 = require("../constants");
+const spark_ui_utils_1 = require("./spark-ui-utils");
+const metadata_resource_1 = require("aws-cdk-lib/core/lib/metadata-resource");
+/**
+ * Spark ETL Jobs class
+ *
+ * ETL jobs support pySpark and Scala languages, for which there are separate
+ * but similar constructors. ETL jobs default to the G2 worker type, but you
+ * can override this default with other supported worker type values
+ * (G1, G2, G4 and G8). ETL jobs defaults to Glue version 4.0, which you can
+ * override to 3.0. The following ETL features are enabled by default:
+ * —enable-metrics, —enable-spark-ui, —enable-continuous-cloudwatch-log.
+ * You can find more details about version, worker type and other features
+ * in Glue's public documentation.
+ */
+class ScalaSparkFlexEtlJob extends job_1.Job {
+    /**
+     * ScalaSparkFlexEtlJob constructor
+     */
+    constructor(scope, id, props) {
+        super(scope, id, {
+            physicalName: props.jobName,
+        });
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_glue_alpha_ScalaSparkFlexEtlJobProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, ScalaSparkFlexEtlJob);
+            }
+            throw error;
+        }
+        // Enhanced CDK Analytics Telemetry
+        (0, metadata_resource_1.addConstructMetadata)(this, props);
+        // Set up role and permissions for principal
+        this.role = props.role, {
+            assumedBy: new iam.ServicePrincipal('glue.amazonaws.com'),
+            managedPolicies: [iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSGlueServiceRole')],
+        };
+        this.grantPrincipal = this.role;
+        // Enable SparkUI by default as a best practice
+        const sparkUIArgs = props.sparkUI?.bucket ? this.setupSparkUI(this.role, props.sparkUI) : undefined;
+        this.sparkUILoggingLocation = sparkUIArgs?.location;
+        // Enable CloudWatch metrics and continuous logging by default as a best practice
+        const continuousLoggingArgs = this.setupContinuousLogging(this.role, props.continuousLogging);
+        const profilingMetricsArgs = { '--enable-metrics': '' };
+        const observabilityMetricsArgs = { '--enable-observability-metrics': 'true' };
+        // Gather executable arguments
+        const execuatbleArgs = this.executableArguments(props);
+        if (props.className === undefined) {
+            throw new Error('className must be set for Scala ETL Jobs');
+        }
+        // Conbine command line arguments into a single line item
+        const defaultArguments = {
+            ...execuatbleArgs,
+            ...continuousLoggingArgs,
+            ...profilingMetricsArgs,
+            ...observabilityMetricsArgs,
+            ...sparkUIArgs?.args,
+            ...this.checkNoReservedArgs(props.defaultArguments),
+        };
+        const jobResource = new aws_glue_1.CfnJob(this, 'Resource', {
+            name: props.jobName,
+            description: props.description,
+            role: this.role.roleArn,
+            command: {
+                name: constants_1.JobType.ETL,
+                scriptLocation: this.codeS3ObjectUrl(props.script),
+            },
+            glueVersion: props.glueVersion ? props.glueVersion : constants_1.GlueVersion.V3_0,
+            workerType: props.workerType ? props.workerType : constants_1.WorkerType.G_1X,
+            numberOfWorkers: props.numberOfWorkers ? props.numberOfWorkers : 10,
+            maxRetries: props.maxRetries,
+            executionProperty: props.maxConcurrentRuns ? { maxConcurrentRuns: props.maxConcurrentRuns } : undefined,
+            notificationProperty: props.notifyDelayAfter ? { notifyDelayAfter: props.notifyDelayAfter.toMinutes() } : undefined,
+            timeout: props.timeout?.toMinutes(),
+            connections: props.connections ? { connections: props.connections.map((connection) => connection.connectionName) } : undefined,
+            securityConfiguration: props.securityConfiguration?.securityConfigurationName,
+            tags: props.tags,
+            executionClass: constants_1.ExecutionClass.FLEX,
+            jobRunQueuingEnabled: false,
+            defaultArguments,
+        });
+        const resourceName = this.getResourceNameAttribute(jobResource.ref);
+        this.jobArn = this.buildJobArn(this, resourceName);
+        this.jobName = resourceName;
+    }
+    /**
+     * Set the executable arguments with best practices enabled by default
+     *
+     * @returns An array of arguments for Glue to use on execution
+     */
+    executableArguments(props) {
+        const args = {};
+        args['--job-language'] = constants_1.JobLanguage.SCALA;
+        args['--class'] = props.className;
+        if (props.extraJars && props.extraJars?.length > 0) {
+            args['--extra-jars'] = props.extraJars.map(code => this.codeS3ObjectUrl(code)).join(',');
+        }
+        if (props.extraFiles && props.extraFiles.length > 0) {
+            args['--extra-files'] = props.extraFiles.map(code => this.codeS3ObjectUrl(code)).join(',');
+        }
+        if (props.extraJarsFirst) {
+            args['--user-jars-first'] = 'true';
+        }
+        return args;
+    }
+    /**
+     * Set the arguments for sparkUI with best practices enabled by default
+     *
+     * @returns An array of arguments for enabling sparkUI
+     */
+    setupSparkUI(role, sparkUiProps) {
+        (0, spark_ui_utils_1.validateSparkUiPrefix)(sparkUiProps.prefix);
+        const bucket = sparkUiProps.bucket ?? new aws_s3_1.Bucket(this, 'SparkUIBucket', { enforceSSL: true, encryption: aws_s3_1.BucketEncryption.S3_MANAGED });
+        bucket.grantReadWrite(role, (0, spark_ui_utils_1.cleanSparkUiPrefixForGrant)(sparkUiProps.prefix));
+        const args = {
+            '--enable-spark-ui': 'true',
+            '--spark-event-logs-path': bucket.s3UrlForObject(sparkUiProps.prefix).replace(/\/?$/, '/'), // path will always end with a slash
+        };
+        return {
+            location: {
+                prefix: sparkUiProps.prefix,
+                bucket,
+            },
+            args,
+        };
+    }
+}
+exports.ScalaSparkFlexEtlJob = ScalaSparkFlexEtlJob;
+_a = JSII_RTTI_SYMBOL_1;
+ScalaSparkFlexEtlJob[_a] = { fqn: "@aws-cdk/aws-glue-alpha.ScalaSparkFlexEtlJob", version: "2.178.0-alpha.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scala-spark-flex-etl-job.js","sourceRoot":"","sources":["scala-spark-flex-etl-job.ts"],"names":[],"mappings":"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","sourcesContent":["import * as iam from 'aws-cdk-lib/aws-iam';\nimport { Bucket, BucketEncryption } from 'aws-cdk-lib/aws-s3';\nimport { CfnJob } from 'aws-cdk-lib/aws-glue';\nimport { Job, JobProperties } from './job';\nimport { Construct } from 'constructs';\nimport { JobType, GlueVersion, JobLanguage, WorkerType, ExecutionClass } from '../constants';\nimport { SparkUIProps, SparkUILoggingLocation, validateSparkUiPrefix, cleanSparkUiPrefixForGrant } from './spark-ui-utils';\nimport * as cdk from 'aws-cdk-lib/core';\nimport { Code } from '../code';\nimport { addConstructMetadata } from 'aws-cdk-lib/core/lib/metadata-resource';\n\n/**\n * Flex Jobs class\n *\n * Flex jobs supports Python and Scala language.\n * The flexible execution class is appropriate for non-urgent jobs such as\n * pre-production jobs, testing, and one-time data loads.\n * Flexible job runs are supported for jobs using AWS Glue version 3.0 or later and G.1X or\n * G.2X worker types but will default to the latest version of Glue (currently Glue 3.0.)\n *\n * Similar to ETL, we’ll enable these features: —enable-metrics, —enable-spark-ui,\n * —enable-continuous-cloudwatch-log\n *\n */\nexport interface ScalaSparkFlexEtlJobProps extends JobProperties {\n  /**\n   * Enables the Spark UI debugging and monitoring with the specified props.\n   *\n   * @default - Spark UI debugging and monitoring is disabled.\n   *\n   * @see https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-jobs.html\n   * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   */\n  readonly sparkUI?: SparkUIProps;\n\n  /**\n   * Specifies configuration properties of a notification (optional).\n   * After a job run starts, the number of minutes to wait before sending a job run delay notification.\n   * @default - undefined\n   */\n  readonly notifyDelayAfter?: cdk.Duration;\n\n  /**\n   * The fully qualified Scala class name that serves as the entry point for the job.\n   *\n   * @see `--class` in https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   */\n  readonly className: string;\n\n  /**\n   * Additional Java .jar files that AWS Glue adds to the Java classpath before executing your script.\n   * Only individual files are supported, directories are not supported.\n   *\n   * @default [] - no extra jars are added to the classpath\n   *\n   * @see `--extra-jars` in https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   */\n  readonly extraJars?: Code[];\n\n  /**\n   * Setting this value to true prioritizes the customer's extra JAR files in the classpath.\n   *\n   * @default false - priority is not given to user-provided jars\n   *\n   * @see `--user-jars-first` in https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   */\n  readonly extraJarsFirst?: boolean;\n\n  /**\n   * Additional files, such as configuration files that AWS Glue copies to the working directory of your script before executing it.\n   * Only individual files are supported, directories are not supported.\n   *\n   * @default [] - no extra files are copied to the working directory\n   *\n   * @see `--extra-files` in https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   */\n  readonly extraFiles?: Code[];\n}\n\n/**\n * Spark ETL Jobs class\n *\n * ETL jobs support pySpark and Scala languages, for which there are separate\n * but similar constructors. ETL jobs default to the G2 worker type, but you\n * can override this default with other supported worker type values\n * (G1, G2, G4 and G8). ETL jobs defaults to Glue version 4.0, which you can\n * override to 3.0. The following ETL features are enabled by default:\n * —enable-metrics, —enable-spark-ui, —enable-continuous-cloudwatch-log.\n * You can find more details about version, worker type and other features\n * in Glue's public documentation.\n */\nexport class ScalaSparkFlexEtlJob extends Job {\n  public readonly jobArn: string;\n  public readonly jobName: string;\n  public readonly role: iam.IRole;\n  public readonly grantPrincipal: iam.IPrincipal;\n\n  /**\n   * The Spark UI logs location if Spark UI monitoring and debugging is enabled.\n   *\n   * @see https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-jobs.html\n   * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   */\n  public readonly sparkUILoggingLocation?: SparkUILoggingLocation;\n\n  /**\n   * ScalaSparkFlexEtlJob constructor\n   */\n  constructor(scope: Construct, id: string, props: ScalaSparkFlexEtlJobProps) {\n    super(scope, id, {\n      physicalName: props.jobName,\n    });\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, props);\n\n    // Set up role and permissions for principal\n    this.role = props.role, {\n      assumedBy: new iam.ServicePrincipal('glue.amazonaws.com'),\n      managedPolicies: [iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSGlueServiceRole')],\n    };\n    this.grantPrincipal = this.role;\n\n    // Enable SparkUI by default as a best practice\n    const sparkUIArgs = props.sparkUI?.bucket ? this.setupSparkUI(this.role, props.sparkUI) : undefined;\n    this.sparkUILoggingLocation = sparkUIArgs?.location;\n\n    // Enable CloudWatch metrics and continuous logging by default as a best practice\n    const continuousLoggingArgs = this.setupContinuousLogging(this.role, props.continuousLogging);\n    const profilingMetricsArgs = { '--enable-metrics': '' };\n    const observabilityMetricsArgs = { '--enable-observability-metrics': 'true' };\n\n    // Gather executable arguments\n    const execuatbleArgs = this.executableArguments(props);\n\n    if (props.className === undefined) {\n      throw new Error('className must be set for Scala ETL Jobs');\n    }\n\n    // Conbine command line arguments into a single line item\n    const defaultArguments = {\n      ...execuatbleArgs,\n      ...continuousLoggingArgs,\n      ...profilingMetricsArgs,\n      ...observabilityMetricsArgs,\n      ...sparkUIArgs?.args,\n      ...this.checkNoReservedArgs(props.defaultArguments),\n    };\n\n    const jobResource = new CfnJob(this, 'Resource', {\n      name: props.jobName,\n      description: props.description,\n      role: this.role.roleArn,\n      command: {\n        name: JobType.ETL,\n        scriptLocation: this.codeS3ObjectUrl(props.script),\n      },\n      glueVersion: props.glueVersion ? props.glueVersion : GlueVersion.V3_0,\n      workerType: props.workerType ? props.workerType : WorkerType.G_1X,\n      numberOfWorkers: props.numberOfWorkers ? props.numberOfWorkers : 10,\n      maxRetries: props.maxRetries,\n      executionProperty: props.maxConcurrentRuns ? { maxConcurrentRuns: props.maxConcurrentRuns } : undefined,\n      notificationProperty: props.notifyDelayAfter ? { notifyDelayAfter: props.notifyDelayAfter.toMinutes() } : undefined,\n      timeout: props.timeout?.toMinutes(),\n      connections: props.connections ? { connections: props.connections.map((connection) => connection.connectionName) } : undefined,\n      securityConfiguration: props.securityConfiguration?.securityConfigurationName,\n      tags: props.tags,\n      executionClass: ExecutionClass.FLEX,\n      jobRunQueuingEnabled: false,\n      defaultArguments,\n    });\n\n    const resourceName = this.getResourceNameAttribute(jobResource.ref);\n    this.jobArn = this.buildJobArn(this, resourceName);\n    this.jobName = resourceName;\n  }\n\n  /**\n   * Set the executable arguments with best practices enabled by default\n   *\n   * @returns An array of arguments for Glue to use on execution\n   */\n  private executableArguments(props: ScalaSparkFlexEtlJobProps) {\n    const args: { [key: string]: string } = {};\n    args['--job-language'] = JobLanguage.SCALA;\n    args['--class'] = props.className!;\n\n    if (props.extraJars && props.extraJars?.length > 0) {\n      args['--extra-jars'] = props.extraJars.map(code => this.codeS3ObjectUrl(code)).join(',');\n    }\n\n    if (props.extraFiles && props.extraFiles.length > 0) {\n      args['--extra-files'] = props.extraFiles.map(code => this.codeS3ObjectUrl(code)).join(',');\n    }\n    if (props.extraJarsFirst) {\n      args['--user-jars-first'] = 'true';\n    }\n    return args;\n  }\n\n  /**\n   * Set the arguments for sparkUI with best practices enabled by default\n   *\n   * @returns An array of arguments for enabling sparkUI\n   */\n  private setupSparkUI(role: iam.IRole, sparkUiProps: SparkUIProps) {\n    validateSparkUiPrefix(sparkUiProps.prefix);\n    const bucket = sparkUiProps.bucket ?? new Bucket(this, 'SparkUIBucket', { enforceSSL: true, encryption: BucketEncryption.S3_MANAGED });\n    bucket.grantReadWrite(role, cleanSparkUiPrefixForGrant(sparkUiProps.prefix));\n    const args = {\n      '--enable-spark-ui': 'true',\n      '--spark-event-logs-path': bucket.s3UrlForObject(sparkUiProps.prefix).replace(/\\/?$/, '/'), // path will always end with a slash\n    };\n\n    return {\n      location: {\n        prefix: sparkUiProps.prefix,\n        bucket,\n      },\n      args,\n    };\n  }\n}\n"]}

package/lib/jobs/scala-spark-streaming-job.d.ts

@@ -0,0 +1,77 @@
+import * as iam from 'aws-cdk-lib/aws-iam';
+import { Job, JobProperties } from './job';
+import { Construct } from 'constructs';
+import { SparkUIProps, SparkUILoggingLocation } from './spark-ui-utils';
+/**
+ * Properties for creating a Scala Spark ETL job
+ */
+export interface ScalaSparkStreamingJobProps extends JobProperties {
+    /**
+     * Enables the Spark UI debugging and monitoring with the specified props.
+     *
+     * @default - Spark UI debugging and monitoring is disabled.
+     *
+     * @see https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-jobs.html
+     * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
+     */
+    readonly sparkUI?: SparkUIProps;
+    /**
+     * Class name (required for Scala scripts)
+     * Package and class name for the entry point of Glue job execution for
+     * Java scripts
+     **/
+    readonly className: string;
+    /**
+     * Extra Jars S3 URL (optional)
+     * S3 URL where additional jar dependencies are located
+     * @default - no extra jar files
+     */
+    readonly extraJars?: string[];
+    /**
+     * Specifies whether job run queuing is enabled for the job runs for this job.
+     * A value of true means job run queuing is enabled for the job runs.
+     * If false or not populated, the job runs will not be considered for queueing.
+     * If this field does not match the value set in the job run, then the value from
+     * the job run field will be used. This property must be set to false for flex jobs.
+     * If this property is enabled, maxRetries must be set to zero.
+     *
+     * @default - no job run queuing
+     */
+    readonly jobRunQueuingEnabled?: boolean;
+}
+/**
+ * Scala Streaming Jobs class
+ *
+ * A Streaming job is similar to an ETL job, except that it performs ETL on data streams
+ * using the Apache Spark Structured Streaming framework.
+ * These jobs will default to use Python 3.9.
+ *
+ * Similar to ETL jobs, streaming job supports Scala and Python languages. Similar to ETL,
+ * it supports G1 and G2 worker type and 2.0, 3.0 and 4.0 version. We’ll default to G2 worker
+ * and 4.0 version for streaming jobs which developers can override.
+ * We will enable —enable-metrics, —enable-spark-ui, —enable-continuous-cloudwatch-log.
+ */
+export declare class ScalaSparkStreamingJob extends Job {
+    readonly jobArn: string;
+    readonly jobName: string;
+    readonly role: iam.IRole;
+    readonly grantPrincipal: iam.IPrincipal;
+    /**
+     * The Spark UI logs location if Spark UI monitoring and debugging is enabled.
+     *
+     * @see https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-jobs.html
+     * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
+     */
+    readonly sparkUILoggingLocation?: SparkUILoggingLocation;
+    /**
+     * ScalaSparkStreamingJob constructor
+     */
+    constructor(scope: Construct, id: string, props: ScalaSparkStreamingJobProps);
+    /**
+     * Set the executable arguments with best practices enabled by default
+     *
+     * @returns An array of arguments for Glue to use on execution
+     */
+    private executableArguments;
+    private setupSparkUI;
+}

package/lib/jobs/scala-spark-streaming-job.js

@@ -0,0 +1,131 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScalaSparkStreamingJob = 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 iam = require("aws-cdk-lib/aws-iam");
+const aws_s3_1 = require("aws-cdk-lib/aws-s3");
+const job_1 = require("./job");
+const constants_1 = require("../constants");
+const spark_ui_utils_1 = require("./spark-ui-utils");
+const metadata_resource_1 = require("aws-cdk-lib/core/lib/metadata-resource");
+/**
+ * Scala Streaming Jobs class
+ *
+ * A Streaming job is similar to an ETL job, except that it performs ETL on data streams
+ * using the Apache Spark Structured Streaming framework.
+ * These jobs will default to use Python 3.9.
+ *
+ * Similar to ETL jobs, streaming job supports Scala and Python languages. Similar to ETL,
+ * it supports G1 and G2 worker type and 2.0, 3.0 and 4.0 version. We’ll default to G2 worker
+ * and 4.0 version for streaming jobs which developers can override.
+ * We will enable —enable-metrics, —enable-spark-ui, —enable-continuous-cloudwatch-log.
+ */
+class ScalaSparkStreamingJob extends job_1.Job {
+    /**
+     * ScalaSparkStreamingJob constructor
+     */
+    constructor(scope, id, props) {
+        super(scope, id, {
+            physicalName: props.jobName,
+        });
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_glue_alpha_ScalaSparkStreamingJobProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, ScalaSparkStreamingJob);
+            }
+            throw error;
+        }
+        // Enhanced CDK Analytics Telemetry
+        (0, metadata_resource_1.addConstructMetadata)(this, props);
+        // Set up role and permissions for principal
+        this.role = props.role, {
+            assumedBy: new iam.ServicePrincipal('glue.amazonaws.com'),
+            managedPolicies: [iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSGlueServiceRole')],
+        };
+        this.grantPrincipal = this.role;
+        // Enable SparkUI by default as a best practice
+        const sparkUIArgs = props.sparkUI?.bucket ? this.setupSparkUI(this.role, props.sparkUI) : undefined;
+        this.sparkUILoggingLocation = sparkUIArgs?.location;
+        // Enable CloudWatch metrics and continuous logging by default as a best practice
+        const continuousLoggingArgs = this.setupContinuousLogging(this.role, props.continuousLogging);
+        const profilingMetricsArgs = { '--enable-metrics': '' };
+        const observabilityMetricsArgs = { '--enable-observability-metrics': 'true' };
+        // Gather executable arguments
+        const executableArgs = this.executableArguments(props);
+        // Mandatory className argument
+        if (props.className === undefined) {
+            throw new Error('className must be set for Scala ETL Jobs');
+        }
+        // Conbine command line arguments into a single line item
+        const defaultArguments = {
+            ...executableArgs,
+            ...continuousLoggingArgs,
+            ...profilingMetricsArgs,
+            ...observabilityMetricsArgs,
+            ...sparkUIArgs?.args,
+            ...this.checkNoReservedArgs(props.defaultArguments),
+        };
+        if ((!props.workerType && props.numberOfWorkers !== undefined) || (props.workerType && props.numberOfWorkers === undefined)) {
+            throw new Error('Both workerType and numberOfWorkers must be set');
+        }
+        const jobResource = new aws_glue_1.CfnJob(this, 'Resource', {
+            name: props.jobName,
+            description: props.description,
+            role: this.role.roleArn,
+            command: {
+                name: constants_1.JobType.STREAMING,
+                scriptLocation: this.codeS3ObjectUrl(props.script),
+            },
+            glueVersion: props.glueVersion ? props.glueVersion : constants_1.GlueVersion.V4_0,
+            workerType: props.workerType ? props.workerType : constants_1.WorkerType.G_1X,
+            numberOfWorkers: props.numberOfWorkers ? props.numberOfWorkers : 10,
+            maxRetries: props.jobRunQueuingEnabled ? 0 : props.maxRetries,
+            jobRunQueuingEnabled: props.jobRunQueuingEnabled ? props.jobRunQueuingEnabled : false,
+            executionProperty: props.maxConcurrentRuns ? { maxConcurrentRuns: props.maxConcurrentRuns } : undefined,
+            timeout: props.timeout?.toMinutes(),
+            connections: props.connections ? { connections: props.connections.map((connection) => connection.connectionName) } : undefined,
+            securityConfiguration: props.securityConfiguration?.securityConfigurationName,
+            tags: props.tags,
+            defaultArguments,
+        });
+        const resourceName = this.getResourceNameAttribute(jobResource.ref);
+        this.jobArn = this.buildJobArn(this, resourceName);
+        this.jobName = resourceName;
+    }
+    /**
+     * Set the executable arguments with best practices enabled by default
+     *
+     * @returns An array of arguments for Glue to use on execution
+     */
+    executableArguments(props) {
+        const args = {};
+        args['--job-language'] = constants_1.JobLanguage.SCALA;
+        args['--class'] = props.className;
+        return args;
+    }
+    setupSparkUI(role, sparkUiProps) {
+        (0, spark_ui_utils_1.validateSparkUiPrefix)(sparkUiProps.prefix);
+        const bucket = sparkUiProps.bucket ?? new aws_s3_1.Bucket(this, 'SparkUIBucket', { enforceSSL: true, encryption: aws_s3_1.BucketEncryption.S3_MANAGED });
+        bucket.grantReadWrite(role, (0, spark_ui_utils_1.cleanSparkUiPrefixForGrant)(sparkUiProps.prefix));
+        const args = {
+            '--enable-spark-ui': 'true',
+            '--spark-event-logs-path': bucket.s3UrlForObject(sparkUiProps.prefix).replace(/\/?$/, '/'), // path will always end with a slash
+        };
+        return {
+            location: {
+                prefix: sparkUiProps.prefix,
+                bucket,
+            },
+            args,
+        };
+    }
+}
+exports.ScalaSparkStreamingJob = ScalaSparkStreamingJob;
+_a = JSII_RTTI_SYMBOL_1;
+ScalaSparkStreamingJob[_a] = { fqn: "@aws-cdk/aws-glue-alpha.ScalaSparkStreamingJob", version: "2.178.0-alpha.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scala-spark-streaming-job.js","sourceRoot":"","sources":["scala-spark-streaming-job.ts"],"names":[],"mappings":"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","sourcesContent":["import { CfnJob } from 'aws-cdk-lib/aws-glue';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport { Bucket, BucketEncryption } from 'aws-cdk-lib/aws-s3';\nimport { Job, JobProperties } from './job';\nimport { Construct } from 'constructs';\nimport { JobType, GlueVersion, JobLanguage, WorkerType } from '../constants';\nimport { SparkUIProps, SparkUILoggingLocation, validateSparkUiPrefix, cleanSparkUiPrefixForGrant } from './spark-ui-utils';\nimport { addConstructMetadata } from 'aws-cdk-lib/core/lib/metadata-resource';\n\n/**\n * Properties for creating a Scala Spark ETL job\n */\nexport interface ScalaSparkStreamingJobProps extends JobProperties {\n  /**\n   * Enables the Spark UI debugging and monitoring with the specified props.\n   *\n   * @default - Spark UI debugging and monitoring is disabled.\n   *\n   * @see https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-jobs.html\n   * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   */\n  readonly sparkUI?: SparkUIProps;\n\n  /**\n   * Class name (required for Scala scripts)\n   * Package and class name for the entry point of Glue job execution for\n   * Java scripts\n   **/\n  readonly className: string;\n\n  /**\n   * Extra Jars S3 URL (optional)\n   * S3 URL where additional jar dependencies are located\n   * @default - no extra jar files\n   */\n  readonly extraJars?: string[];\n\n  /**\n   * Specifies whether job run queuing is enabled for the job runs for this job.\n   * A value of true means job run queuing is enabled for the job runs.\n   * If false or not populated, the job runs will not be considered for queueing.\n   * If this field does not match the value set in the job run, then the value from\n   * the job run field will be used. This property must be set to false for flex jobs.\n   * If this property is enabled, maxRetries must be set to zero.\n   *\n   * @default - no job run queuing\n   */\n  readonly jobRunQueuingEnabled?: boolean;\n}\n\n/**\n * Scala Streaming Jobs class\n *\n * A Streaming job is similar to an ETL job, except that it performs ETL on data streams\n * using the Apache Spark Structured Streaming framework.\n * These jobs will default to use Python 3.9.\n *\n * Similar to ETL jobs, streaming job supports Scala and Python languages. Similar to ETL,\n * it supports G1 and G2 worker type and 2.0, 3.0 and 4.0 version. We’ll default to G2 worker\n * and 4.0 version for streaming jobs which developers can override.\n * We will enable —enable-metrics, —enable-spark-ui, —enable-continuous-cloudwatch-log.\n */\nexport class ScalaSparkStreamingJob extends Job {\n  public readonly jobArn: string;\n  public readonly jobName: string;\n  public readonly role: iam.IRole;\n  public readonly grantPrincipal: iam.IPrincipal;\n\n  /**\n   * The Spark UI logs location if Spark UI monitoring and debugging is enabled.\n   *\n   * @see https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-jobs.html\n   * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   */\n  public readonly sparkUILoggingLocation?: SparkUILoggingLocation;\n\n  /**\n   * ScalaSparkStreamingJob constructor\n   */\n  constructor(scope: Construct, id: string, props: ScalaSparkStreamingJobProps) {\n    super(scope, id, {\n      physicalName: props.jobName,\n    });\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, props);\n\n    // Set up role and permissions for principal\n    this.role = props.role, {\n      assumedBy: new iam.ServicePrincipal('glue.amazonaws.com'),\n      managedPolicies: [iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSGlueServiceRole')],\n    };\n    this.grantPrincipal = this.role;\n\n    // Enable SparkUI by default as a best practice\n    const sparkUIArgs = props.sparkUI?.bucket ? this.setupSparkUI(this.role, props.sparkUI) : undefined;\n    this.sparkUILoggingLocation = sparkUIArgs?.location;\n\n    // Enable CloudWatch metrics and continuous logging by default as a best practice\n    const continuousLoggingArgs = this.setupContinuousLogging(this.role, props.continuousLogging);\n    const profilingMetricsArgs = { '--enable-metrics': '' };\n    const observabilityMetricsArgs = { '--enable-observability-metrics': 'true' };\n\n    // Gather executable arguments\n    const executableArgs = this.executableArguments(props);\n\n    // Mandatory className argument\n    if (props.className === undefined) {\n      throw new Error('className must be set for Scala ETL Jobs');\n    }\n\n    // Conbine command line arguments into a single line item\n    const defaultArguments = {\n      ...executableArgs,\n      ...continuousLoggingArgs,\n      ...profilingMetricsArgs,\n      ...observabilityMetricsArgs,\n      ...sparkUIArgs?.args,\n      ...this.checkNoReservedArgs(props.defaultArguments),\n    };\n\n    if ((!props.workerType && props.numberOfWorkers !== undefined) || (props.workerType && props.numberOfWorkers === undefined)) {\n      throw new Error('Both workerType and numberOfWorkers must be set');\n    }\n\n    const jobResource = new CfnJob(this, 'Resource', {\n      name: props.jobName,\n      description: props.description,\n      role: this.role.roleArn,\n      command: {\n        name: JobType.STREAMING,\n        scriptLocation: this.codeS3ObjectUrl(props.script),\n      },\n      glueVersion: props.glueVersion ? props.glueVersion : GlueVersion.V4_0,\n      workerType: props.workerType ? props.workerType : WorkerType.G_1X,\n      numberOfWorkers: props.numberOfWorkers ? props.numberOfWorkers : 10,\n      maxRetries: props.jobRunQueuingEnabled ? 0 : props.maxRetries,\n      jobRunQueuingEnabled: props.jobRunQueuingEnabled ? props.jobRunQueuingEnabled : false,\n      executionProperty: props.maxConcurrentRuns ? { maxConcurrentRuns: props.maxConcurrentRuns } : undefined,\n      timeout: props.timeout?.toMinutes(),\n      connections: props.connections ? { connections: props.connections.map((connection) => connection.connectionName) } : undefined,\n      securityConfiguration: props.securityConfiguration?.securityConfigurationName,\n      tags: props.tags,\n      defaultArguments,\n    });\n\n    const resourceName = this.getResourceNameAttribute(jobResource.ref);\n    this.jobArn = this.buildJobArn(this, resourceName);\n    this.jobName = resourceName;\n  }\n\n  /**\n   * Set the executable arguments with best practices enabled by default\n   *\n   * @returns An array of arguments for Glue to use on execution\n   */\n  private executableArguments(props: ScalaSparkStreamingJobProps) {\n    const args: { [key: string]: string } = {};\n    args['--job-language'] = JobLanguage.SCALA;\n    args['--class'] = props.className!;\n\n    return args;\n  }\n\n  private setupSparkUI(role: iam.IRole, sparkUiProps: SparkUIProps) {\n    validateSparkUiPrefix(sparkUiProps.prefix);\n    const bucket = sparkUiProps.bucket ?? new Bucket(this, 'SparkUIBucket', { enforceSSL: true, encryption: BucketEncryption.S3_MANAGED });\n    bucket.grantReadWrite(role, cleanSparkUiPrefixForGrant(sparkUiProps.prefix));\n    const args = {\n      '--enable-spark-ui': 'true',\n      '--spark-event-logs-path': bucket.s3UrlForObject(sparkUiProps.prefix).replace(/\\/?$/, '/'), // path will always end with a slash\n    };\n\n    return {\n      location: {\n        prefix: sparkUiProps.prefix,\n        bucket,\n      },\n      args,\n    };\n  }\n}\n"]}

package/lib/jobs/spark-ui-utils.d.ts

@@ -0,0 +1,53 @@
+import { IBucket } from 'aws-cdk-lib/aws-s3';
+/**
+ * Properties for enabling Spark UI monitoring feature for Spark-based Glue jobs.
+ *
+ * @see https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-jobs.html
+ * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
+ */
+export interface SparkUIProps {
+    /**
+     * The bucket where the Glue job stores the logs.
+     *
+     * @default a new bucket will be created.
+     */
+    readonly bucket?: IBucket;
+    /**
+     * The path inside the bucket (objects prefix) where the Glue job stores the logs.
+     * Use format `'/foo/bar'`
+     *
+     * @default - the logs will be written at the root of the bucket
+     */
+    readonly prefix?: string;
+    /**
+     * Specifies whether job run queuing is enabled for the job runs for this job.
+     * A value of true means job run queuing is enabled for the job runs.
+     * If false or not populated, the job runs will not be considered for queueing.
+     * If this field does not match the value set in the job run, then the value from
+     * the job run field will be used. This property must be set to false for flex jobs.
+     * If this property is enabled, maxRetries must be set to zero.
+     *
+     * @default - no job run queuing
+     */
+    readonly jobRunQueuingEnabled?: boolean;
+}
+/**
+ * The Spark UI logging location.
+ *
+ * @see https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-jobs.html
+ * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
+ */
+export interface SparkUILoggingLocation {
+    /**
+     * The bucket where the Glue job stores the logs.
+     */
+    readonly bucket: IBucket;
+    /**
+     * The path inside the bucket (objects prefix) where the Glue job stores the logs.
+     *
+     * @default '/' - the logs will be written at the root of the bucket
+     */
+    readonly prefix?: string;
+}
+export declare function validateSparkUiPrefix(prefix?: string): void;
+export declare function cleanSparkUiPrefixForGrant(prefix?: string): string | undefined;

package/lib/jobs/spark-ui-utils.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSparkUiPrefix = validateSparkUiPrefix;
+exports.cleanSparkUiPrefixForGrant = cleanSparkUiPrefixForGrant;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const os_1 = require("os");
+function validateSparkUiPrefix(prefix) {
+    if (!prefix || aws_cdk_lib_1.Token.isUnresolved(prefix)) {
+        // skip validation if prefix is not specified or is a token
+        return;
+    }
+    const errors = [];
+    if (!prefix.startsWith('/')) {
+        errors.push('Prefix must begin with \'/\'');
+    }
+    if (prefix.endsWith('/')) {
+        errors.push('Prefix must not end with \'/\'');
+    }
+    if (errors.length > 0) {
+        throw new Error(`Invalid prefix format (value: ${prefix})${os_1.EOL}${errors.join(os_1.EOL)}`);
+    }
+}
+function cleanSparkUiPrefixForGrant(prefix) {
+    return prefix !== undefined ? prefix.slice(1) + '/*' : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BhcmstdWktdXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJzcGFyay11aS11dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQTJEQSxzREFtQkM7QUFFRCxnRUFFQztBQWpGRCw2Q0FBb0M7QUFDcEMsMkJBQXlCO0FBeUR6QixTQUFnQixxQkFBcUIsQ0FBQyxNQUFlO0lBQ25ELElBQUksQ0FBQyxNQUFNLElBQUksbUJBQUssQ0FBQyxZQUFZLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQztRQUMxQywyREFBMkQ7UUFDM0QsT0FBTztJQUNULENBQUM7SUFFRCxNQUFNLE1BQU0sR0FBYSxFQUFFLENBQUM7SUFFNUIsSUFBSSxDQUFDLE1BQU0sQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQztRQUM1QixNQUFNLENBQUMsSUFBSSxDQUFDLDhCQUE4QixDQUFDLENBQUM7SUFDOUMsQ0FBQztJQUVELElBQUksTUFBTSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDO1FBQ3pCLE1BQU0sQ0FBQyxJQUFJLENBQUMsZ0NBQWdDLENBQUMsQ0FBQztJQUNoRCxDQUFDO0lBRUQsSUFBSSxNQUFNLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRSxDQUFDO1FBQ3RCLE1BQU0sSUFBSSxLQUFLLENBQUMsaUNBQWlDLE1BQU0sSUFBSSxRQUFHLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxRQUFHLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDdkYsQ0FBQztBQUNILENBQUM7QUFFRCxTQUFnQiwwQkFBMEIsQ0FBQyxNQUFlO0lBQ3hELE9BQU8sTUFBTSxLQUFLLFNBQVMsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsR0FBRyxJQUFJLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQztBQUNuRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSUJ1Y2tldCB9IGZyb20gJ2F3cy1jZGstbGliL2F3cy1zMyc7XG5pbXBvcnQgeyBUb2tlbiB9IGZyb20gJ2F3cy1jZGstbGliJztcbmltcG9ydCB7IEVPTCB9IGZyb20gJ29zJztcblxuLyoqXG4gKiBQcm9wZXJ0aWVzIGZvciBlbmFibGluZyBTcGFyayBVSSBtb25pdG9yaW5nIGZlYXR1cmUgZm9yIFNwYXJrLWJhc2VkIEdsdWUgam9icy5cbiAqXG4gKiBAc2VlIGh0dHBzOi8vZG9jcy5hd3MuYW1hem9uLmNvbS9nbHVlL2xhdGVzdC9kZy9tb25pdG9yLXNwYXJrLXVpLWpvYnMuaHRtbFxuICogQHNlZSBodHRwczovL2RvY3MuYXdzLmFtYXpvbi5jb20vZ2x1ZS9sYXRlc3QvZGcvYXdzLWdsdWUtcHJvZ3JhbW1pbmctZXRsLWdsdWUtYXJndW1lbnRzLmh0bWxcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBTcGFya1VJUHJvcHMge1xuICAvKipcbiAgICogVGhlIGJ1Y2tldCB3aGVyZSB0aGUgR2x1ZSBqb2Igc3RvcmVzIHRoZSBsb2dzLlxuICAgKlxuICAgKiBAZGVmYXVsdCBhIG5ldyBidWNrZXQgd2lsbCBiZSBjcmVhdGVkLlxuICAgKi9cbiAgcmVhZG9ubHkgYnVja2V0PzogSUJ1Y2tldDtcblxuICAvKipcbiAgICogVGhlIHBhdGggaW5zaWRlIHRoZSBidWNrZXQgKG9iamVjdHMgcHJlZml4KSB3aGVyZSB0aGUgR2x1ZSBqb2Igc3RvcmVzIHRoZSBsb2dzLlxuICAgKiBVc2UgZm9ybWF0IGAnL2Zvby9iYXInYFxuICAgKlxuICAgKiBAZGVmYXVsdCAtIHRoZSBsb2dzIHdpbGwgYmUgd3JpdHRlbiBhdCB0aGUgcm9vdCBvZiB0aGUgYnVja2V0XG4gICAqL1xuICByZWFkb25seSBwcmVmaXg/OiBzdHJpbmc7XG5cbiAgLyoqXG4gICAqIFNwZWNpZmllcyB3aGV0aGVyIGpvYiBydW4gcXVldWluZyBpcyBlbmFibGVkIGZvciB0aGUgam9iIHJ1bnMgZm9yIHRoaXMgam9iLlxuICAgKiBBIHZhbHVlIG9mIHRydWUgbWVhbnMgam9iIHJ1biBxdWV1aW5nIGlzIGVuYWJsZWQgZm9yIHRoZSBqb2IgcnVucy5cbiAgICogSWYgZmFsc2Ugb3Igbm90IHBvcHVsYXRlZCwgdGhlIGpvYiBydW5zIHdpbGwgbm90IGJlIGNvbnNpZGVyZWQgZm9yIHF1ZXVlaW5nLlxuICAgKiBJZiB0aGlzIGZpZWxkIGRvZXMgbm90IG1hdGNoIHRoZSB2YWx1ZSBzZXQgaW4gdGhlIGpvYiBydW4sIHRoZW4gdGhlIHZhbHVlIGZyb21cbiAgICogdGhlIGpvYiBydW4gZmllbGQgd2lsbCBiZSB1c2VkLiBUaGlzIHByb3BlcnR5IG11c3QgYmUgc2V0IHRvIGZhbHNlIGZvciBmbGV4IGpvYnMuXG4gICAqIElmIHRoaXMgcHJvcGVydHkgaXMgZW5hYmxlZCwgbWF4UmV0cmllcyBtdXN0IGJlIHNldCB0byB6ZXJvLlxuICAgKlxuICAgKiBAZGVmYXVsdCAtIG5vIGpvYiBydW4gcXVldWluZ1xuICAgKi9cbiAgcmVhZG9ubHkgam9iUnVuUXVldWluZ0VuYWJsZWQ/OiBib29sZWFuO1xufVxuXG4vKipcbiAqIFRoZSBTcGFyayBVSSBsb2dnaW5nIGxvY2F0aW9uLlxuICpcbiAqIEBzZWUgaHR0cHM6Ly9kb2NzLmF3cy5hbWF6b24uY29tL2dsdWUvbGF0ZXN0L2RnL21vbml0b3Itc3BhcmstdWktam9icy5odG1sXG4gKiBAc2VlIGh0dHBzOi8vZG9jcy5hd3MuYW1hem9uLmNvbS9nbHVlL2xhdGVzdC9kZy9hd3MtZ2x1ZS1wcm9ncmFtbWluZy1ldGwtZ2x1ZS1hcmd1bWVudHMuaHRtbFxuICovXG5leHBvcnQgaW50ZXJmYWNlIFNwYXJrVUlMb2dnaW5nTG9jYXRpb24ge1xuICAvKipcbiAgICogVGhlIGJ1Y2tldCB3aGVyZSB0aGUgR2x1ZSBqb2Igc3RvcmVzIHRoZSBsb2dzLlxuICAgKi9cbiAgcmVhZG9ubHkgYnVja2V0OiBJQnVja2V0O1xuXG4gIC8qKlxuICAgKiBUaGUgcGF0aCBpbnNpZGUgdGhlIGJ1Y2tldCAob2JqZWN0cyBwcmVmaXgpIHdoZXJlIHRoZSBHbHVlIGpvYiBzdG9yZXMgdGhlIGxvZ3MuXG4gICAqXG4gICAqIEBkZWZhdWx0ICcvJyAtIHRoZSBsb2dzIHdpbGwgYmUgd3JpdHRlbiBhdCB0aGUgcm9vdCBvZiB0aGUgYnVja2V0XG4gICAqL1xuICByZWFkb25seSBwcmVmaXg/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiB2YWxpZGF0ZVNwYXJrVWlQcmVmaXgocHJlZml4Pzogc3RyaW5nKTogdm9pZCB7XG4gIGlmICghcHJlZml4IHx8IFRva2VuLmlzVW5yZXNvbHZlZChwcmVmaXgpKSB7XG4gICAgLy8gc2tpcCB2YWxpZGF0aW9uIGlmIHByZWZpeCBpcyBub3Qgc3BlY2lmaWVkIG9yIGlzIGEgdG9rZW5cbiAgICByZXR1cm47XG4gIH1cblxuICBjb25zdCBlcnJvcnM6IHN0cmluZ1tdID0gW107XG5cbiAgaWYgKCFwcmVmaXguc3RhcnRzV2l0aCgnLycpKSB7XG4gICAgZXJyb3JzLnB1c2goJ1ByZWZpeCBtdXN0IGJlZ2luIHdpdGggXFwnL1xcJycpO1xuICB9XG5cbiAgaWYgKHByZWZpeC5lbmRzV2l0aCgnLycpKSB7XG4gICAgZXJyb3JzLnB1c2goJ1ByZWZpeCBtdXN0IG5vdCBlbmQgd2l0aCBcXCcvXFwnJyk7XG4gIH1cblxuICBpZiAoZXJyb3JzLmxlbmd0aCA+IDApIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoYEludmFsaWQgcHJlZml4IGZvcm1hdCAodmFsdWU6ICR7cHJlZml4fSkke0VPTH0ke2Vycm9ycy5qb2luKEVPTCl9YCk7XG4gIH1cbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGNsZWFuU3BhcmtVaVByZWZpeEZvckdyYW50KHByZWZpeD86IHN0cmluZyk6IHN0cmluZyB8IHVuZGVmaW5lZCB7XG4gIHJldHVybiBwcmVmaXggIT09IHVuZGVmaW5lZCA/IHByZWZpeC5zbGljZSgxKSArICcvKicgOiB1bmRlZmluZWQ7XG59XG4iXX0=

package/lib/s3-table.d.ts

@@ -35,10 +35,10 @@ export declare enum TableEncryption {
 }
 export interface S3TableProps extends TableBaseProps {
     /**
-   * S3 bucket in which to store data.
-   *
-   * @default one is created for you
-   */
+     * S3 bucket in which to store data.
+     *
+     * @default one is created for you
+     */
     readonly bucket?: s3.IBucket;
     /**
      * S3 prefix under which table objects are stored.