@aws-cdk/aws-glue-alpha 2.237.1-alpha.0 → 2.239.0-alpha.0

package/lib/partition-projection.d.ts

@@ -0,0 +1,243 @@
+/**
+ * Partition projection type.
+ *
+ * Determines how Athena projects partition values.
+ *
+ * @see https://docs.aws.amazon.com/athena/latest/ug/partition-projection-supported-types.html
+ */
+export declare enum PartitionProjectionType {
+    /**
+     * Project partition values as integers within a range.
+     */
+    INTEGER = "integer",
+    /**
+     * Project partition values as dates within a range.
+     */
+    DATE = "date",
+    /**
+     * Project partition values from an explicit list of values.
+     */
+    ENUM = "enum",
+    /**
+     * Project partition values that are injected at query time.
+     */
+    INJECTED = "injected"
+}
+/**
+ * Date interval unit for partition projection.
+ *
+ * @see https://docs.aws.amazon.com/athena/latest/ug/partition-projection-supported-types.html#partition-projection-date-type
+ */
+export declare enum DateIntervalUnit {
+    /**
+     * Year interval.
+     */
+    YEARS = "YEARS",
+    /**
+     * Month interval.
+     */
+    MONTHS = "MONTHS",
+    /**
+     * Week interval.
+     */
+    WEEKS = "WEEKS",
+    /**
+     * Day interval (default).
+     */
+    DAYS = "DAYS",
+    /**
+     * Hour interval.
+     */
+    HOURS = "HOURS",
+    /**
+     * Minute interval.
+     */
+    MINUTES = "MINUTES",
+    /**
+     * Second interval.
+     */
+    SECONDS = "SECONDS"
+}
+/**
+ * Properties for INTEGER partition projection configuration.
+ */
+export interface IntegerPartitionProjectionConfigurationProps {
+    /**
+     * Minimum value for the integer partition range (inclusive).
+     */
+    readonly min: number;
+    /**
+     * Maximum value for the integer partition range (inclusive).
+     */
+    readonly max: number;
+    /**
+     * Interval between partition values.
+     *
+     * @default 1
+     */
+    readonly interval?: number;
+    /**
+     * Number of digits to pad the partition value with leading zeros.
+     *
+     * With digits: 4, partition values: 0001, 0002, ..., 0100
+     *
+     * @default - no static number of digits and no leading zeroes
+     */
+    readonly digits?: number;
+}
+/**
+ * Properties for DATE partition projection configuration.
+ */
+export interface DatePartitionProjectionConfigurationProps {
+    /**
+     * Start date for the partition range (inclusive).
+     *
+     * Can be either:
+     * - Fixed date in the format specified by `format` property
+     *   (e.g., '2020-01-01' for format 'yyyy-MM-dd')
+     * - Relative date using NOW syntax
+     *   (e.g., 'NOW', 'NOW-3YEARS', 'NOW+1MONTH')
+     *
+     * @see https://docs.aws.amazon.com/athena/latest/ug/partition-projection-supported-types.html#partition-projection-date-type
+     */
+    readonly min: string;
+    /**
+     * End date for the partition range (inclusive).
+     *
+     * Can be either:
+     * - Fixed date in the format specified by `format` property
+     * - Relative date using NOW syntax
+     *
+     * Same format constraints as `min`.
+     */
+    readonly max: string;
+    /**
+     * Date format for partition values.
+     *
+     * Uses Java SimpleDateFormat patterns.
+     *
+     * @see https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html
+     */
+    readonly format: string;
+    /**
+     * Interval between partition values.
+     *
+     * When the provided dates are at single-day or single-month precision,
+     * the interval is optional and defaults to 1 day or 1 month, respectively.
+     * Otherwise, interval is required.
+     *
+     * @default - 1 for single-day or single-month precision, otherwise required
+     */
+    readonly interval?: number;
+    /**
+     * Unit for the interval.
+     *
+     * When the provided dates are at single-day or single-month precision,
+     * the intervalUnit is optional and defaults to 1 day or 1 month, respectively.
+     * Otherwise, the intervalUnit is required.
+     *
+     * @default - DAYS for single-day precision, MONTHS for single-month precision, otherwise required
+     */
+    readonly intervalUnit?: DateIntervalUnit;
+}
+/**
+ * Properties for ENUM partition projection configuration.
+ */
+export interface EnumPartitionProjectionConfigurationProps {
+    /**
+     * Explicit list of partition values.
+     *
+     * @example ['us-east-1', 'us-west-2', 'eu-west-1']
+     */
+    readonly values: string[];
+}
+/**
+ * Factory class for creating partition projection configurations.
+ */
+export declare class PartitionProjectionConfiguration {
+    /**
+     * Create an INTEGER partition projection configuration.
+     */
+    static integer(props: IntegerPartitionProjectionConfigurationProps): PartitionProjectionConfiguration;
+    /**
+     * Create a DATE partition projection configuration.
+     */
+    static date(props: DatePartitionProjectionConfigurationProps): PartitionProjectionConfiguration;
+    /**
+     * Create an ENUM partition projection configuration.
+     */
+    static enum(props: EnumPartitionProjectionConfigurationProps): PartitionProjectionConfiguration;
+    /**
+     * Create an INJECTED partition projection configuration.
+     *
+     * Partition values are injected at query time through the query statement.
+     *
+     * @see https://docs.aws.amazon.com/athena/latest/ug/partition-projection-supported-types.html#partition-projection-injected-type
+     */
+    static injected(): PartitionProjectionConfiguration;
+    /**
+     * The type of partition projection.
+     */
+    readonly type: PartitionProjectionType;
+    /**
+     * Range of partition values for INTEGER type.
+     *
+     * Array of [min, max] as numbers.
+     */
+    readonly integerRange?: number[];
+    /**
+     * Range of partition values for DATE type.
+     *
+     * Array of [start, end] as date strings.
+     */
+    readonly dateRange?: string[];
+    /**
+     * Interval between partition values.
+     */
+    readonly interval?: number;
+    /**
+     * Number of digits to pad INTEGER partition values.
+     */
+    readonly digits?: number;
+    /**
+     * Date format for DATE partition values (Java SimpleDateFormat).
+     */
+    readonly format?: string;
+    /**
+     * Unit for DATE partition interval.
+     */
+    readonly intervalUnit?: DateIntervalUnit;
+    /**
+     * Explicit list of values for ENUM partitions.
+     */
+    readonly values?: string[];
+    private constructor();
+    /**
+     * Renders CloudFormation parameters for this partition projection configuration.
+     *
+     * @param columnName - The partition column name
+     * @internal
+     */
+    _renderParameters(columnName: string): {
+        [key: string]: string;
+    };
+}
+/**
+ * Partition projection configuration for a table.
+ *
+ * Maps partition column names to their projection configurations.
+ * The key is the partition column name, the value is the partition configuration.
+ */
+export type PartitionProjection = {
+    [columnName: string]: PartitionProjectionConfiguration;
+};
+/**
+ * Generates CloudFormation parameters for partition projection configuration.
+ *
+ * @param columnName - The partition column name
+ * @param config - The partition configuration
+ * @returns CloudFormation parameters
+ */
+export declare function generatePartitionProjectionParameters(columnName: string, config: PartitionProjectionConfiguration): {
+    [key: string]: string;
+};

package/lib/partition-projection.js

@@ -0,0 +1,339 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PartitionProjectionConfiguration = exports.DateIntervalUnit = exports.PartitionProjectionType = void 0;
+exports.generatePartitionProjectionParameters = generatePartitionProjectionParameters;
+const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+/**
+ * Partition projection type.
+ *
+ * Determines how Athena projects partition values.
+ *
+ * @see https://docs.aws.amazon.com/athena/latest/ug/partition-projection-supported-types.html
+ */
+var PartitionProjectionType;
+(function (PartitionProjectionType) {
+    /**
+     * Project partition values as integers within a range.
+     */
+    PartitionProjectionType["INTEGER"] = "integer";
+    /**
+     * Project partition values as dates within a range.
+     */
+    PartitionProjectionType["DATE"] = "date";
+    /**
+     * Project partition values from an explicit list of values.
+     */
+    PartitionProjectionType["ENUM"] = "enum";
+    /**
+     * Project partition values that are injected at query time.
+     */
+    PartitionProjectionType["INJECTED"] = "injected";
+})(PartitionProjectionType || (exports.PartitionProjectionType = PartitionProjectionType = {}));
+/**
+ * Date interval unit for partition projection.
+ *
+ * @see https://docs.aws.amazon.com/athena/latest/ug/partition-projection-supported-types.html#partition-projection-date-type
+ */
+var DateIntervalUnit;
+(function (DateIntervalUnit) {
+    /**
+     * Year interval.
+     */
+    DateIntervalUnit["YEARS"] = "YEARS";
+    /**
+     * Month interval.
+     */
+    DateIntervalUnit["MONTHS"] = "MONTHS";
+    /**
+     * Week interval.
+     */
+    DateIntervalUnit["WEEKS"] = "WEEKS";
+    /**
+     * Day interval (default).
+     */
+    DateIntervalUnit["DAYS"] = "DAYS";
+    /**
+     * Hour interval.
+     */
+    DateIntervalUnit["HOURS"] = "HOURS";
+    /**
+     * Minute interval.
+     */
+    DateIntervalUnit["MINUTES"] = "MINUTES";
+    /**
+     * Second interval.
+     */
+    DateIntervalUnit["SECONDS"] = "SECONDS";
+})(DateIntervalUnit || (exports.DateIntervalUnit = DateIntervalUnit = {}));
+/**
+ * Factory class for creating partition projection configurations.
+ */
+class PartitionProjectionConfiguration {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-glue-alpha.PartitionProjectionConfiguration", version: "2.239.0-alpha.0" };
+    /**
+     * Create an INTEGER partition projection configuration.
+     */
+    static integer(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_glue_alpha_IntegerPartitionProjectionConfigurationProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.integer);
+            }
+            throw error;
+        }
+        // Validate min/max are integers
+        if (!aws_cdk_lib_1.Token.isUnresolved(props.min) && !aws_cdk_lib_1.Token.isUnresolved(props.max)) {
+            if (!Number.isInteger(props.min) || !Number.isInteger(props.max)) {
+                throw new aws_cdk_lib_1.UnscopedValidationError(`INTEGER partition projection range must contain integers, but got [${props.min}, ${props.max}]`);
+            }
+            // Validate min <= max
+            if (props.min > props.max) {
+                throw new aws_cdk_lib_1.UnscopedValidationError(`INTEGER partition projection range must be [min, max] where min <= max, but got [${props.min}, ${props.max}]`);
+            }
+        }
+        // Validate interval
+        if (props.interval !== undefined &&
+            !aws_cdk_lib_1.Token.isUnresolved(props.interval) &&
+            (!Number.isInteger(props.interval) || props.interval <= 0)) {
+            throw new aws_cdk_lib_1.UnscopedValidationError(`INTEGER partition projection interval must be a positive integer, but got ${props.interval}`);
+        }
+        // Validate digits
+        if (props.digits !== undefined &&
+            !aws_cdk_lib_1.Token.isUnresolved(props.digits) &&
+            (!Number.isInteger(props.digits) || props.digits < 1)) {
+            throw new aws_cdk_lib_1.UnscopedValidationError(`INTEGER partition projection digits must be an integer >= 1, but got ${props.digits}`);
+        }
+        return new PartitionProjectionConfiguration({
+            type: PartitionProjectionType.INTEGER,
+            integerRange: [props.min, props.max],
+            interval: props.interval,
+            digits: props.digits,
+        });
+    }
+    /**
+     * Create a DATE partition projection configuration.
+     */
+    static date(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_glue_alpha_DatePartitionProjectionConfigurationProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.date);
+            }
+            throw error;
+        }
+        // Validate min/max are not empty
+        if (!aws_cdk_lib_1.Token.isUnresolved(props.min) &&
+            !aws_cdk_lib_1.Token.isUnresolved(props.max) &&
+            (props.min.trim() === '' || props.max.trim() === '')) {
+            throw new aws_cdk_lib_1.UnscopedValidationError('DATE partition projection range must not contain empty strings');
+        }
+        // Validate format
+        if (!aws_cdk_lib_1.Token.isUnresolved(props.format)) {
+            // Validate format is not empty
+            if (props.format.trim() === '') {
+                throw new aws_cdk_lib_1.UnscopedValidationError('DATE partition projection format must be a non-empty string');
+            }
+            // Validate format pattern characters (Java 8 DateTimeFormatter)
+            const validPatternLetters = 'GyuYDMLdQqwWEecFahKkHmsSAnNVzOXxZp';
+            const format = props.format;
+            let inQuote = false;
+            const invalidChars = [];
+            for (let i = 0; i < format.length; i++) {
+                const ch = format[i];
+                if (ch === "'") {
+                    if (i + 1 < format.length && format[i + 1] === "'") {
+                        // '' is an escaped single quote literal, skip both
+                        i++;
+                    }
+                    else {
+                        inQuote = !inQuote;
+                    }
+                }
+                else if (!inQuote && /[a-zA-Z]/.test(ch)) {
+                    if (!validPatternLetters.includes(ch)) {
+                        invalidChars.push(ch);
+                    }
+                }
+            }
+            if (inQuote) {
+                throw new aws_cdk_lib_1.UnscopedValidationError(`DATE partition projection format has an unclosed single quote: '${format}'`);
+            }
+            if (invalidChars.length > 0) {
+                const unique = [...new Set(invalidChars)];
+                throw new aws_cdk_lib_1.UnscopedValidationError(`DATE partition projection format contains invalid pattern characters: ${unique.join(', ')}. Must use Java DateTimeFormatter valid pattern letters.`);
+            }
+        }
+        // Validate interval
+        if (props.interval !== undefined &&
+            !aws_cdk_lib_1.Token.isUnresolved(props.interval) &&
+            (!Number.isInteger(props.interval) || props.interval <= 0)) {
+            throw new aws_cdk_lib_1.UnscopedValidationError(`DATE partition projection interval must be a positive integer, but got ${props.interval}`);
+        }
+        return new PartitionProjectionConfiguration({
+            type: PartitionProjectionType.DATE,
+            dateRange: [props.min, props.max],
+            interval: props.interval,
+            format: props.format,
+            intervalUnit: props.intervalUnit,
+        });
+    }
+    /**
+     * Create an ENUM partition projection configuration.
+     */
+    static enum(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_glue_alpha_EnumPartitionProjectionConfigurationProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.enum);
+            }
+            throw error;
+        }
+        // Validate values is not empty
+        if (props.values.length === 0) {
+            throw new aws_cdk_lib_1.UnscopedValidationError('ENUM partition projection values must be a non-empty array');
+        }
+        for (let i = 0; i < props.values.length; i++) {
+            const value = props.values[i];
+            if (!aws_cdk_lib_1.Token.isUnresolved(value)) {
+                if (value.trim() === '') {
+                    throw new aws_cdk_lib_1.UnscopedValidationError('ENUM partition projection values must not contain empty strings');
+                }
+                if (value.includes(',')) {
+                    throw new aws_cdk_lib_1.UnscopedValidationError(`ENUM partition projection values must not contain commas because the values are serialized as a comma-separated list, got: '${value}'`);
+                }
+            }
+        }
+        return new PartitionProjectionConfiguration({
+            type: PartitionProjectionType.ENUM,
+            values: props.values,
+        });
+    }
+    /**
+     * Create an INJECTED partition projection configuration.
+     *
+     * Partition values are injected at query time through the query statement.
+     *
+     * @see https://docs.aws.amazon.com/athena/latest/ug/partition-projection-supported-types.html#partition-projection-injected-type
+     */
+    static injected() {
+        return new PartitionProjectionConfiguration({
+            type: PartitionProjectionType.INJECTED,
+        });
+    }
+    /**
+     * The type of partition projection.
+     */
+    type;
+    /**
+     * Range of partition values for INTEGER type.
+     *
+     * Array of [min, max] as numbers.
+     */
+    integerRange;
+    /**
+     * Range of partition values for DATE type.
+     *
+     * Array of [start, end] as date strings.
+     */
+    dateRange;
+    /**
+     * Interval between partition values.
+     */
+    interval;
+    /**
+     * Number of digits to pad INTEGER partition values.
+     */
+    digits;
+    /**
+     * Date format for DATE partition values (Java SimpleDateFormat).
+     */
+    format;
+    /**
+     * Unit for DATE partition interval.
+     */
+    intervalUnit;
+    /**
+     * Explicit list of values for ENUM partitions.
+     */
+    values;
+    constructor(props) {
+        this.type = props.type;
+        this.integerRange = props.integerRange;
+        this.dateRange = props.dateRange;
+        this.interval = props.interval;
+        this.digits = props.digits;
+        this.format = props.format;
+        this.intervalUnit = props.intervalUnit;
+        this.values = props.values;
+    }
+    /**
+     * Renders CloudFormation parameters for this partition projection configuration.
+     *
+     * @param columnName - The partition column name
+     * @internal
+     */
+    _renderParameters(columnName) {
+        const params = {
+            [`projection.${columnName}.type`]: this.type,
+        };
+        switch (this.type) {
+            case PartitionProjectionType.INTEGER: {
+                const [min, max] = this.integerRange;
+                params[`projection.${columnName}.range`] = `${min},${max}`;
+                if (this.interval !== undefined) {
+                    params[`projection.${columnName}.interval`] = this.interval.toString();
+                }
+                if (this.digits !== undefined) {
+                    params[`projection.${columnName}.digits`] = this.digits.toString();
+                }
+                break;
+            }
+            case PartitionProjectionType.DATE: {
+                const [start, end] = this.dateRange;
+                params[`projection.${columnName}.range`] = `${start},${end}`;
+                params[`projection.${columnName}.format`] = this.format;
+                if (this.interval !== undefined) {
+                    params[`projection.${columnName}.interval`] = this.interval.toString();
+                }
+                if (this.intervalUnit !== undefined) {
+                    params[`projection.${columnName}.interval.unit`] = this.intervalUnit;
+                }
+                break;
+            }
+            case PartitionProjectionType.ENUM: {
+                params[`projection.${columnName}.values`] = this.values.join(',');
+                break;
+            }
+            case PartitionProjectionType.INJECTED: {
+                // INJECTED has no additional parameters
+                break;
+            }
+            default: {
+                // TypeScript exhaustiveness check
+                const exhaustiveCheck = this.type;
+                throw new aws_cdk_lib_1.UnscopedValidationError(`Unknown partition projection type for "${columnName}": ${exhaustiveCheck}`);
+            }
+        }
+        return params;
+    }
+}
+exports.PartitionProjectionConfiguration = PartitionProjectionConfiguration;
+/**
+ * Generates CloudFormation parameters for partition projection configuration.
+ *
+ * @param columnName - The partition column name
+ * @param config - The partition configuration
+ * @returns CloudFormation parameters
+ */
+function generatePartitionProjectionParameters(columnName, config) {
+    return config._renderParameters(columnName);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"partition-projection.js","sourceRoot":"","sources":["partition-projection.ts"],"names":[],"mappings":"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","sourcesContent":["import { Token, UnscopedValidationError } from 'aws-cdk-lib';\n\n/**\n * Partition projection type.\n *\n * Determines how Athena projects partition values.\n *\n * @see https://docs.aws.amazon.com/athena/latest/ug/partition-projection-supported-types.html\n */\nexport enum PartitionProjectionType {\n  /**\n   * Project partition values as integers within a range.\n   */\n  INTEGER = 'integer',\n\n  /**\n   * Project partition values as dates within a range.\n   */\n  DATE = 'date',\n\n  /**\n   * Project partition values from an explicit list of values.\n   */\n  ENUM = 'enum',\n\n  /**\n   * Project partition values that are injected at query time.\n   */\n  INJECTED = 'injected',\n}\n\n/**\n * Date interval unit for partition projection.\n *\n * @see https://docs.aws.amazon.com/athena/latest/ug/partition-projection-supported-types.html#partition-projection-date-type\n */\nexport enum DateIntervalUnit {\n  /**\n   * Year interval.\n   */\n  YEARS = 'YEARS',\n\n  /**\n   * Month interval.\n   */\n  MONTHS = 'MONTHS',\n\n  /**\n   * Week interval.\n   */\n  WEEKS = 'WEEKS',\n\n  /**\n   * Day interval (default).\n   */\n  DAYS = 'DAYS',\n\n  /**\n   * Hour interval.\n   */\n  HOURS = 'HOURS',\n\n  /**\n   * Minute interval.\n   */\n  MINUTES = 'MINUTES',\n\n  /**\n   * Second interval.\n   */\n  SECONDS = 'SECONDS',\n}\n\n/**\n * Properties for INTEGER partition projection configuration.\n */\nexport interface IntegerPartitionProjectionConfigurationProps {\n  /**\n   * Minimum value for the integer partition range (inclusive).\n   */\n  readonly min: number;\n\n  /**\n   * Maximum value for the integer partition range (inclusive).\n   */\n  readonly max: number;\n\n  /**\n   * Interval between partition values.\n   *\n   * @default 1\n   */\n  readonly interval?: number;\n\n  /**\n   * Number of digits to pad the partition value with leading zeros.\n   *\n   * With digits: 4, partition values: 0001, 0002, ..., 0100\n   *\n   * @default - no static number of digits and no leading zeroes\n   */\n  readonly digits?: number;\n}\n\n/**\n * Properties for DATE partition projection configuration.\n */\nexport interface DatePartitionProjectionConfigurationProps {\n  /**\n   * Start date for the partition range (inclusive).\n   *\n   * Can be either:\n   * - Fixed date in the format specified by `format` property\n   *   (e.g., '2020-01-01' for format 'yyyy-MM-dd')\n   * - Relative date using NOW syntax\n   *   (e.g., 'NOW', 'NOW-3YEARS', 'NOW+1MONTH')\n   *\n   * @see https://docs.aws.amazon.com/athena/latest/ug/partition-projection-supported-types.html#partition-projection-date-type\n   */\n  readonly min: string;\n\n  /**\n   * End date for the partition range (inclusive).\n   *\n   * Can be either:\n   * - Fixed date in the format specified by `format` property\n   * - Relative date using NOW syntax\n   *\n   * Same format constraints as `min`.\n   */\n  readonly max: string;\n\n  /**\n   * Date format for partition values.\n   *\n   * Uses Java SimpleDateFormat patterns.\n   *\n   * @see https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html\n   */\n  readonly format: string;\n\n  /**\n   * Interval between partition values.\n   *\n   * When the provided dates are at single-day or single-month precision,\n   * the interval is optional and defaults to 1 day or 1 month, respectively.\n   * Otherwise, interval is required.\n   *\n   * @default - 1 for single-day or single-month precision, otherwise required\n   */\n  readonly interval?: number;\n\n  /**\n   * Unit for the interval.\n   *\n   * When the provided dates are at single-day or single-month precision,\n   * the intervalUnit is optional and defaults to 1 day or 1 month, respectively.\n   * Otherwise, the intervalUnit is required.\n   *\n   * @default - DAYS for single-day precision, MONTHS for single-month precision, otherwise required\n   */\n  readonly intervalUnit?: DateIntervalUnit;\n}\n\n/**\n * Properties for ENUM partition projection configuration.\n */\nexport interface EnumPartitionProjectionConfigurationProps {\n  /**\n   * Explicit list of partition values.\n   *\n   * @example ['us-east-1', 'us-west-2', 'eu-west-1']\n   */\n  readonly values: string[];\n}\n\n/**\n * Internal properties for PartitionProjectionConfiguration.\n */\ninterface PartitionProjectionConfigurationProps {\n  /**\n   * The type of partition projection.\n   */\n  readonly type: PartitionProjectionType;\n\n  /**\n   * Range of partition values for INTEGER type.\n   *\n   * Array of [min, max] as numbers.\n   */\n  readonly integerRange?: number[];\n\n  /**\n   * Range of partition values for DATE type.\n   *\n   * Array of [start, end] as date strings.\n   */\n  readonly dateRange?: string[];\n\n  /**\n   * Interval between partition values.\n   */\n  readonly interval?: number;\n\n  /**\n   * Number of digits to pad INTEGER partition values.\n   */\n  readonly digits?: number;\n\n  /**\n   * Date format for DATE partition values (Java SimpleDateFormat).\n   */\n  readonly format?: string;\n\n  /**\n   * Unit for DATE partition interval.\n   */\n  readonly intervalUnit?: DateIntervalUnit;\n\n  /**\n   * Explicit list of values for ENUM partitions.\n   */\n  readonly values?: string[];\n}\n\n/**\n * Factory class for creating partition projection configurations.\n */\nexport class PartitionProjectionConfiguration {\n  /**\n   * Create an INTEGER partition projection configuration.\n   */\n  public static integer(props: IntegerPartitionProjectionConfigurationProps): PartitionProjectionConfiguration {\n    // Validate min/max are integers\n    if (!Token.isUnresolved(props.min) && !Token.isUnresolved(props.max)) {\n      if (!Number.isInteger(props.min) || !Number.isInteger(props.max)) {\n        throw new UnscopedValidationError(\n          `INTEGER partition projection range must contain integers, but got [${props.min}, ${props.max}]`,\n        );\n      }\n\n      // Validate min <= max\n      if (props.min > props.max) {\n        throw new UnscopedValidationError(\n          `INTEGER partition projection range must be [min, max] where min <= max, but got [${props.min}, ${props.max}]`,\n        );\n      }\n    }\n\n    // Validate interval\n    if (\n      props.interval !== undefined &&\n      !Token.isUnresolved(props.interval) &&\n      (!Number.isInteger(props.interval) || props.interval <= 0)\n    ) {\n      throw new UnscopedValidationError(\n        `INTEGER partition projection interval must be a positive integer, but got ${props.interval}`,\n      );\n    }\n\n    // Validate digits\n    if (\n      props.digits !== undefined &&\n      !Token.isUnresolved(props.digits) &&\n      (!Number.isInteger(props.digits) || props.digits < 1)\n    ) {\n      throw new UnscopedValidationError(\n        `INTEGER partition projection digits must be an integer >= 1, but got ${props.digits}`,\n      );\n    }\n\n    return new PartitionProjectionConfiguration({\n      type: PartitionProjectionType.INTEGER,\n      integerRange: [props.min, props.max],\n      interval: props.interval,\n      digits: props.digits,\n    });\n  }\n\n  /**\n   * Create a DATE partition projection configuration.\n   */\n  public static date(props: DatePartitionProjectionConfigurationProps): PartitionProjectionConfiguration {\n    // Validate min/max are not empty\n    if (\n      !Token.isUnresolved(props.min) &&\n      !Token.isUnresolved(props.max) &&\n      (props.min.trim() === '' || props.max.trim() === '')\n    ) {\n      throw new UnscopedValidationError(\n        'DATE partition projection range must not contain empty strings',\n      );\n    }\n\n    // Validate format\n    if (!Token.isUnresolved(props.format)) {\n      // Validate format is not empty\n      if (props.format.trim() === '') {\n        throw new UnscopedValidationError(\n          'DATE partition projection format must be a non-empty string',\n        );\n      }\n\n      // Validate format pattern characters (Java 8 DateTimeFormatter)\n      const validPatternLetters = 'GyuYDMLdQqwWEecFahKkHmsSAnNVzOXxZp';\n      const format = props.format;\n      let inQuote = false;\n      const invalidChars: string[] = [];\n\n      for (let i = 0; i < format.length; i++) {\n        const ch = format[i];\n        if (ch === \"'\") {\n          if (i + 1 < format.length && format[i + 1] === \"'\") {\n            // '' is an escaped single quote literal, skip both\n            i++;\n          } else {\n            inQuote = !inQuote;\n          }\n        } else if (!inQuote && /[a-zA-Z]/.test(ch)) {\n          if (!validPatternLetters.includes(ch)) {\n            invalidChars.push(ch);\n          }\n        }\n      }\n\n      if (inQuote) {\n        throw new UnscopedValidationError(\n          `DATE partition projection format has an unclosed single quote: '${format}'`,\n        );\n      }\n\n      if (invalidChars.length > 0) {\n        const unique = [...new Set(invalidChars)];\n        throw new UnscopedValidationError(\n          `DATE partition projection format contains invalid pattern characters: ${unique.join(', ')}. Must use Java DateTimeFormatter valid pattern letters.`,\n        );\n      }\n    }\n\n    // Validate interval\n    if (\n      props.interval !== undefined &&\n      !Token.isUnresolved(props.interval) &&\n      (!Number.isInteger(props.interval) || props.interval <= 0)\n    ) {\n      throw new UnscopedValidationError(\n        `DATE partition projection interval must be a positive integer, but got ${props.interval}`,\n      );\n    }\n\n    return new PartitionProjectionConfiguration({\n      type: PartitionProjectionType.DATE,\n      dateRange: [props.min, props.max],\n      interval: props.interval,\n      format: props.format,\n      intervalUnit: props.intervalUnit,\n    });\n  }\n\n  /**\n   * Create an ENUM partition projection configuration.\n   */\n  public static enum(props: EnumPartitionProjectionConfigurationProps): PartitionProjectionConfiguration {\n    // Validate values is not empty\n    if (props.values.length === 0) {\n      throw new UnscopedValidationError(\n        'ENUM partition projection values must be a non-empty array',\n      );\n    }\n\n    for (let i = 0; i < props.values.length; i++) {\n      const value = props.values[i];\n      if (!Token.isUnresolved(value)) {\n        if (value.trim() === '') {\n          throw new UnscopedValidationError(\n            'ENUM partition projection values must not contain empty strings',\n          );\n        }\n        if (value.includes(',')) {\n          throw new UnscopedValidationError(\n            `ENUM partition projection values must not contain commas because the values are serialized as a comma-separated list, got: '${value}'`,\n          );\n        }\n      }\n    }\n\n    return new PartitionProjectionConfiguration({\n      type: PartitionProjectionType.ENUM,\n      values: props.values,\n    });\n  }\n\n  /**\n   * Create an INJECTED partition projection configuration.\n   *\n   * Partition values are injected at query time through the query statement.\n   *\n   * @see https://docs.aws.amazon.com/athena/latest/ug/partition-projection-supported-types.html#partition-projection-injected-type\n   */\n  public static injected(): PartitionProjectionConfiguration {\n    return new PartitionProjectionConfiguration({\n      type: PartitionProjectionType.INJECTED,\n    });\n  }\n\n  /**\n   * The type of partition projection.\n   */\n  public readonly type: PartitionProjectionType;\n\n  /**\n   * Range of partition values for INTEGER type.\n   *\n   * Array of [min, max] as numbers.\n   */\n  public readonly integerRange?: number[];\n\n  /**\n   * Range of partition values for DATE type.\n   *\n   * Array of [start, end] as date strings.\n   */\n  public readonly dateRange?: string[];\n\n  /**\n   * Interval between partition values.\n   */\n  public readonly interval?: number;\n\n  /**\n   * Number of digits to pad INTEGER partition values.\n   */\n  public readonly digits?: number;\n\n  /**\n   * Date format for DATE partition values (Java SimpleDateFormat).\n   */\n  public readonly format?: string;\n\n  /**\n   * Unit for DATE partition interval.\n   */\n  public readonly intervalUnit?: DateIntervalUnit;\n\n  /**\n   * Explicit list of values for ENUM partitions.\n   */\n  public readonly values?: string[];\n\n  private constructor(props: PartitionProjectionConfigurationProps) {\n    this.type = props.type;\n    this.integerRange = props.integerRange;\n    this.dateRange = props.dateRange;\n    this.interval = props.interval;\n    this.digits = props.digits;\n    this.format = props.format;\n    this.intervalUnit = props.intervalUnit;\n    this.values = props.values;\n  }\n\n  /**\n   * Renders CloudFormation parameters for this partition projection configuration.\n   *\n   * @param columnName - The partition column name\n   * @internal\n   */\n  public _renderParameters(columnName: string): { [key: string]: string } {\n    const params: { [key: string]: string } = {\n      [`projection.${columnName}.type`]: this.type,\n    };\n\n    switch (this.type) {\n      case PartitionProjectionType.INTEGER: {\n        const [min, max] = this.integerRange!;\n        params[`projection.${columnName}.range`] = `${min},${max}`;\n        if (this.interval !== undefined) {\n          params[`projection.${columnName}.interval`] = this.interval.toString();\n        }\n        if (this.digits !== undefined) {\n          params[`projection.${columnName}.digits`] = this.digits.toString();\n        }\n        break;\n      }\n      case PartitionProjectionType.DATE: {\n        const [start, end] = this.dateRange!;\n        params[`projection.${columnName}.range`] = `${start},${end}`;\n        params[`projection.${columnName}.format`] = this.format!;\n        if (this.interval !== undefined) {\n          params[`projection.${columnName}.interval`] = this.interval.toString();\n        }\n        if (this.intervalUnit !== undefined) {\n          params[`projection.${columnName}.interval.unit`] = this.intervalUnit;\n        }\n        break;\n      }\n      case PartitionProjectionType.ENUM: {\n        params[`projection.${columnName}.values`] = this.values!.join(',');\n        break;\n      }\n      case PartitionProjectionType.INJECTED: {\n        // INJECTED has no additional parameters\n        break;\n      }\n      default: {\n        // TypeScript exhaustiveness check\n        const exhaustiveCheck: never = this.type;\n        throw new UnscopedValidationError(\n          `Unknown partition projection type for \"${columnName}\": ${exhaustiveCheck}`,\n        );\n      }\n    }\n\n    return params;\n  }\n}\n\n/**\n * Partition projection configuration for a table.\n *\n * Maps partition column names to their projection configurations.\n * The key is the partition column name, the value is the partition configuration.\n */\nexport type PartitionProjection = {\n  [columnName: string]: PartitionProjectionConfiguration;\n};\n\n/**\n * Generates CloudFormation parameters for partition projection configuration.\n *\n * @param columnName - The partition column name\n * @param config - The partition configuration\n * @returns CloudFormation parameters\n */\nexport function generatePartitionProjectionParameters(\n  columnName: string,\n  config: PartitionProjectionConfiguration,\n): { [key: string]: string } {\n  return config._renderParameters(columnName);\n}\n"]}

package/lib/s3-table.d.ts

@@ -1,9 +1,10 @@
 import { CfnTable } from 'aws-cdk-lib/aws-glue';
-import * as iam from 'aws-cdk-lib/aws-iam';
+import type * as iam from 'aws-cdk-lib/aws-iam';
 import * as kms from 'aws-cdk-lib/aws-kms';
 import * as s3 from 'aws-cdk-lib/aws-s3';
-import { Construct } from 'constructs';
-import { PartitionIndex, TableBase, TableBaseProps } from './table-base';
+import type { Construct } from 'constructs';
+import type { PartitionIndex, TableBaseProps } from './table-base';
+import { TableBase } from './table-base';
 /**
  * Encryption options for a Table.
  *