flexdataset 0.21.1 → 0.22.0

package/dist/src/table-types/iceberg-parquet-v2.js

@@ -0,0 +1,469 @@
+"use strict";
+/**
+ * Iceberg (parquet) format-version-2 table type.
+ *
+ * Iceberg partitions are transforms applied to a data column, so duplicate
+ * detection keys on the (source column, normalized transform) pair — `year(ts)`
+ * and `month(ts)` are distinct, while `day` and `DAY` collapse.
+ *
+ * The format version is encoded in the `tableType` discriminator: this engine is
+ * inherently v2, so a present `formatVersion` must equal `EXPECTED_FORMAT_VERSION`.
+ * A future `iceberg_parquet_v3` sibling subclass overrides that one constant.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IcebergParquetV2Table = void 0;
+const table_type_1 = require("../table-type");
+const iceberg_1 = require("../iceberg");
+/**
+ * Whether a string is a positive integer (digits only, value > 0). Iceberg
+ * table-property values are strings, so numeric checks parse the string.
+ *
+ * @param value Property value string.
+ * @returns True when `value` is a positive integer.
+ */
+function isPositiveInteger(value) {
+    return /^\d+$/.test(value) && Number(value) > 0;
+}
+/**
+ * Whether a string is a non-negative integer (digits only, value >= 0).
+ *
+ * @param value Property value string.
+ * @returns True when `value` is a non-negative integer.
+ */
+function isNonNegativeInteger(value) {
+    return /^\d+$/.test(value);
+}
+/**
+ * Whether a string is an integer within an inclusive range.
+ *
+ * @param value Property value string.
+ * @param min Inclusive lower bound.
+ * @param max Inclusive upper bound.
+ * @returns True when `value` is an integer in `[min, max]`.
+ */
+function isIntegerInRange(value, min, max) {
+    if (!/^\d+$/.test(value)) {
+        return false;
+    }
+    const parsed = Number(value);
+    return parsed >= min && parsed <= max;
+}
+/** Iceberg (parquet) format-version-2 table. */
+class IcebergParquetV2Table extends table_type_1.TableTypeBase {
+    /**
+     * The Iceberg format version this engine pins to. A present `formatVersion`
+     * must equal this. A future v3 sibling subclass overrides this single value.
+     */
+    static EXPECTED_FORMAT_VERSION = 2;
+    /**
+     * Validate a column type against the Iceberg v0 type registry.
+     *
+     * @param type Type string from a column definition.
+     * @returns True when the type is a valid Iceberg type.
+     */
+    isValidColumnType(type) {
+        return (0, iceberg_1.isValidIcebergType)(type);
+    }
+    /**
+     * Iceberg partition rules.
+     *
+     * Emits: `NO_DUPLICATE_PARTITIONS` (keyed by `${name} ${transformKind}:${param}`,
+     * falling back to a lowercased trim of the raw transform when it doesn't
+     * parse, so whitespace / case variants of the same transform collapse),
+     * `ICEBERG_TRANSFORM_SOURCE_EXISTS`, `ICEBERG_TRANSFORM_VALID`, and
+     * `ICEBERG_TRANSFORM_SOURCE_TYPE_LEGAL`.
+     *
+     * @returns Every partition-related violation.
+     */
+    partitionViolations() {
+        const violations = [];
+        const { partitions, } = this.definition;
+        const seen = new Set();
+        partitions.forEach((partition, index) => {
+            const key = this.partitionKey(partition);
+            if (seen.has(key)) {
+                violations.push(this.violation({
+                    level: 'error',
+                    code: 'NO_DUPLICATE_PARTITIONS',
+                    field: `partitions[${index}]`,
+                    message: `duplicate partition: "${partition.name}" with transform "${partition.type}"`,
+                }));
+            }
+            seen.add(key);
+        });
+        partitions.forEach((partition, index) => {
+            const sourceColumn = this.definition.columns.find((column) => column.name === partition.name);
+            if (sourceColumn === undefined) {
+                violations.push(this.violation({
+                    level: 'error',
+                    code: 'ICEBERG_TRANSFORM_SOURCE_EXISTS',
+                    field: `partitions[${index}].name`,
+                    message: `Iceberg partition source column "${partition.name}" is not defined in columns`,
+                }));
+                return;
+            }
+            const transform = (0, iceberg_1.parseIcebergTransform)(partition.type);
+            if (transform === null) {
+                violations.push(this.violation({
+                    level: 'error',
+                    code: 'ICEBERG_TRANSFORM_VALID',
+                    field: `partitions[${index}].type`,
+                    message: `"${partition.type}" is not a valid Iceberg partition transform`,
+                }));
+                return;
+            }
+            const sourceType = (0, iceberg_1.parseIcebergType)(sourceColumn.type);
+            if (sourceType !== null && !(0, iceberg_1.transformLegalOnType)(transform, sourceType)) {
+                violations.push(this.violation({
+                    level: 'error',
+                    code: 'ICEBERG_TRANSFORM_SOURCE_TYPE_LEGAL',
+                    field: `partitions[${index}].type`,
+                    message: `transform "${partition.type}" is not legal on `
+                        + `column "${partition.name}" of type "${sourceColumn.type}"`,
+                }));
+            }
+        });
+        return violations;
+    }
+    /// Table-property keys whose value must come from a closed set.
+    static ENUM_PROPERTIES = {
+        'write.format.default': [
+            'parquet',
+            'avro',
+            'orc',
+        ],
+        'write.parquet.compression-codec': [
+            'zstd',
+            'gzip',
+            'snappy',
+            'lz4',
+            'none',
+        ],
+        'write.avro.compression-codec': [
+            'gzip',
+            'zstd',
+            'snappy',
+            'uncompressed',
+        ],
+        'write.orc.compression-codec': [
+            'zstd',
+            'lz4',
+            'lzo',
+            'zlib',
+            'snappy',
+            'none',
+        ],
+        'write.distribution-mode': [
+            'none',
+            'hash',
+            'range',
+        ],
+        'write.metadata.compression-codec': [
+            'none',
+            'gzip',
+        ],
+    };
+    /// Table-property keys whose value must be a positive integer.
+    static POSITIVE_INT_PROPERTIES = [
+        'write.target-file-size-bytes',
+        'history.expire.max-snapshot-age-ms',
+        'history.expire.min-snapshots-to-keep',
+        'history.expire.max-ref-age-ms',
+        'write.metadata.previous-versions-max',
+        'commit.retry.min-wait-ms',
+        'commit.retry.max-wait-ms',
+        'commit.retry.total-timeout-ms',
+    ];
+    /// Table-property keys whose value must be a non-negative integer.
+    static NON_NEGATIVE_INT_PROPERTIES = [
+        'commit.retry.num-retries',
+    ];
+    /// Table-property keys whose value must be an integer within an inclusive range.
+    static INT_RANGE_PROPERTIES = {
+        'write.parquet.compression-level': {
+            min: 1,
+            max: 22,
+        },
+    };
+    /// Legal sort directions and null orderings.
+    static SORT_DIRECTIONS = new Set([
+        'asc',
+        'desc',
+    ]);
+    static SORT_NULL_ORDERS = new Set([
+        'nulls-first',
+        'nulls-last',
+    ]);
+    /**
+     * Iceberg engine-specific rules: format version, table properties, and sort
+     * order.
+     *
+     * @returns Every engine-specific violation.
+     */
+    engineSpecificViolations() {
+        return [
+            ...this.formatVersionViolations(),
+            ...this.tablePropertyViolations(),
+            ...this.sortOrderViolations(),
+            ...this.identifierFieldViolations(),
+        ];
+    }
+    /**
+     * Validate the Iceberg sort order.
+     *
+     * Emits `NO_DUPLICATE_SORT_FIELDS` (keyed by source column + normalized
+     * transform), `ICEBERG_SORT_COLUMN_EXISTS`, `ICEBERG_SORT_DIRECTION_VALID`,
+     * `ICEBERG_SORT_NULL_ORDER_VALID`, `ICEBERG_SORT_TRANSFORM_VALID`, and
+     * `ICEBERG_SORT_TRANSFORM_TYPE_LEGAL`.
+     *
+     * @returns Every sort-order violation.
+     */
+    sortOrderViolations() {
+        const violations = [];
+        const { sortOrder, } = this.definition;
+        const seen = new Set();
+        sortOrder.forEach((field, index) => {
+            const key = this.sortFieldKey(field);
+            if (seen.has(key)) {
+                violations.push(this.violation({
+                    level: 'error',
+                    code: 'NO_DUPLICATE_SORT_FIELDS',
+                    field: `sortOrder[${index}]`,
+                    message: `duplicate sort field: "${field.column}"`
+                        + `${field.transform ? ` with transform "${field.transform}"` : ''}`,
+                }));
+            }
+            seen.add(key);
+        });
+        sortOrder.forEach((field, index) => {
+            if (!IcebergParquetV2Table.SORT_DIRECTIONS.has(field.direction)) {
+                violations.push(this.violation({
+                    level: 'error',
+                    code: 'ICEBERG_SORT_DIRECTION_VALID',
+                    field: `sortOrder[${index}].direction`,
+                    message: `sort direction "${field.direction}" must be "asc" or "desc"`,
+                }));
+            }
+            if (!IcebergParquetV2Table.SORT_NULL_ORDERS.has(field.nullOrder)) {
+                violations.push(this.violation({
+                    level: 'error',
+                    code: 'ICEBERG_SORT_NULL_ORDER_VALID',
+                    field: `sortOrder[${index}].nullOrder`,
+                    message: `sort null order "${field.nullOrder}" must be "nulls-first" or "nulls-last"`,
+                }));
+            }
+            const sourceColumn = this.definition.columns.find((column) => column.name === field.column);
+            if (sourceColumn === undefined) {
+                violations.push(this.violation({
+                    level: 'error',
+                    code: 'ICEBERG_SORT_COLUMN_EXISTS',
+                    field: `sortOrder[${index}].column`,
+                    message: `sort column "${field.column}" is not defined in columns`,
+                }));
+                return;
+            }
+            if (field.transform === undefined) {
+                return;
+            }
+            const transform = (0, iceberg_1.parseIcebergTransform)(field.transform);
+            if (transform === null) {
+                violations.push(this.violation({
+                    level: 'error',
+                    code: 'ICEBERG_SORT_TRANSFORM_VALID',
+                    field: `sortOrder[${index}].transform`,
+                    message: `"${field.transform}" is not a valid Iceberg transform`,
+                }));
+                return;
+            }
+            const sourceType = (0, iceberg_1.parseIcebergType)(sourceColumn.type);
+            if (sourceType !== null && !(0, iceberg_1.transformLegalOnType)(transform, sourceType)) {
+                violations.push(this.violation({
+                    level: 'error',
+                    code: 'ICEBERG_SORT_TRANSFORM_TYPE_LEGAL',
+                    field: `sortOrder[${index}].transform`,
+                    message: `transform "${field.transform}" is not legal on `
+                        + `column "${field.column}" of type "${sourceColumn.type}"`,
+                }));
+            }
+        });
+        return violations;
+    }
+    /**
+     * Normalize a sort field into its identity key. An omitted transform and an
+     * explicit `identity` collapse to the same key so they count as duplicates.
+     *
+     * @param field Sort field to key.
+     * @returns The identity string for duplicate detection.
+     */
+    sortFieldKey(field) {
+        if (field.transform === undefined) {
+            return `${field.column} identity:`;
+        }
+        const transform = (0, iceberg_1.parseIcebergTransform)(field.transform);
+        const normalizedTransform = transform
+            ? `${transform.kind}:${transform.param ?? ''}`
+            : field.transform.trim().toLowerCase();
+        return `${field.column} ${normalizedTransform}`;
+    }
+    /// ICEBERG_FORMAT_VERSION_VALID — `formatVersion`, when set, equals the
+    /// version this engine pins to (2 for `iceberg_parquet_v2`).
+    formatVersionViolations() {
+        const { formatVersion, } = this.definition;
+        const expected = this.constructor.EXPECTED_FORMAT_VERSION;
+        if (formatVersion === undefined || formatVersion === expected) {
+            return [];
+        }
+        return [
+            this.violation({
+                level: 'error',
+                code: 'ICEBERG_FORMAT_VERSION_VALID',
+                field: 'formatVersion',
+                message: `Iceberg formatVersion "${formatVersion}" must be ${expected}`,
+            }),
+        ];
+    }
+    /**
+     * Validate the closed-domain Iceberg table properties. Keys outside the
+     * known set pass through unvalidated.
+     *
+     * Emits `ICEBERG_PROPERTY_ENUM_VALID`, `ICEBERG_PROPERTY_POSITIVE_INT`,
+     * `ICEBERG_PROPERTY_NON_NEGATIVE_INT`, `ICEBERG_PROPERTY_INT_RANGE`, and
+     * `ICEBERG_COMMIT_RETRY_ORDERING`.
+     *
+     * @returns Every table-property violation.
+     */
+    tablePropertyViolations() {
+        const violations = [];
+        const properties = this.definition.tableProperties;
+        for (const [key, value,] of Object.entries(properties)) {
+            const allowed = IcebergParquetV2Table.ENUM_PROPERTIES[key];
+            if (allowed !== undefined && !allowed.includes(value)) {
+                violations.push(this.violation({
+                    level: 'error',
+                    code: 'ICEBERG_PROPERTY_ENUM_VALID',
+                    field: `tableProperties["${key}"]`,
+                    message: `table property "${key}" value "${value}" must be one of: ${allowed.join(', ')}`,
+                }));
+            }
+            if (IcebergParquetV2Table.POSITIVE_INT_PROPERTIES.includes(key) && !isPositiveInteger(value)) {
+                violations.push(this.violation({
+                    level: 'error',
+                    code: 'ICEBERG_PROPERTY_POSITIVE_INT',
+                    field: `tableProperties["${key}"]`,
+                    message: `table property "${key}" value "${value}" must be a positive integer`,
+                }));
+            }
+            if (IcebergParquetV2Table.NON_NEGATIVE_INT_PROPERTIES.includes(key) && !isNonNegativeInteger(value)) {
+                violations.push(this.violation({
+                    level: 'error',
+                    code: 'ICEBERG_PROPERTY_NON_NEGATIVE_INT',
+                    field: `tableProperties["${key}"]`,
+                    message: `table property "${key}" value "${value}" must be a non-negative integer`,
+                }));
+            }
+            const range = IcebergParquetV2Table.INT_RANGE_PROPERTIES[key];
+            if (range !== undefined && !isIntegerInRange(value, range.min, range.max)) {
+                violations.push(this.violation({
+                    level: 'error',
+                    code: 'ICEBERG_PROPERTY_INT_RANGE',
+                    field: `tableProperties["${key}"]`,
+                    message: `table property "${key}" value "${value}" must be an integer between `
+                        + `${range.min} and ${range.max}`,
+                }));
+            }
+        }
+        violations.push(...this.commitRetryOrderingViolations(properties));
+        return violations;
+    }
+    /// ICEBERG_COMMIT_RETRY_ORDERING — commit.retry waits obey
+    /// min-wait-ms <= max-wait-ms <= total-timeout-ms when all are positive ints.
+    commitRetryOrderingViolations(properties) {
+        const values = [
+            properties['commit.retry.min-wait-ms'],
+            properties['commit.retry.max-wait-ms'],
+            properties['commit.retry.total-timeout-ms'],
+        ];
+        if (!values.every((value) => value !== undefined && isPositiveInteger(value))) {
+            return [];
+        }
+        const [min, max, total,] = values.map(Number);
+        if (min <= max && max <= total) {
+            return [];
+        }
+        return [
+            this.violation({
+                level: 'error',
+                code: 'ICEBERG_COMMIT_RETRY_ORDERING',
+                field: 'tableProperties["commit.retry.min-wait-ms"]',
+                message: 'commit.retry waits must satisfy min-wait-ms <= max-wait-ms <= total-timeout-ms',
+            }),
+        ];
+    }
+    /**
+     * Validate Iceberg identifier fields (the row-identity / equality-delete
+     * key). Equality deletes are a v2 feature, which this engine inherently is;
+     * identifier fields must be required primitive columns that are not
+     * float/double.
+     *
+     * Emits `ICEBERG_IDENTIFIER_COLUMN_EXISTS`, `ICEBERG_IDENTIFIER_REQUIRED`,
+     * and `ICEBERG_IDENTIFIER_TYPE_PRIMITIVE`.
+     *
+     * @returns Every identifier-field violation.
+     */
+    identifierFieldViolations() {
+        const violations = [];
+        const { identifierFields, } = this.definition;
+        if (identifierFields.length === 0) {
+            return [];
+        }
+        identifierFields.forEach((name, index) => {
+            const field = `identifierFields[${index}]`;
+            const column = this.definition.columns.find((candidate) => candidate.name === name);
+            if (column === undefined) {
+                violations.push(this.violation({
+                    level: 'error',
+                    code: 'ICEBERG_IDENTIFIER_COLUMN_EXISTS',
+                    field,
+                    message: `identifier field "${name}" is not defined in columns`,
+                }));
+                return;
+            }
+            if (column.nullable === true) {
+                violations.push(this.violation({
+                    level: 'error',
+                    code: 'ICEBERG_IDENTIFIER_REQUIRED',
+                    field,
+                    message: `identifier field "${name}" must be required (nullable: false)`,
+                }));
+            }
+            const type = (0, iceberg_1.parseIcebergType)(column.type);
+            if (type === null || type.kind === iceberg_1.IcebergTypeKind.FLOAT || type.kind === iceberg_1.IcebergTypeKind.DOUBLE) {
+                violations.push(this.violation({
+                    level: 'error',
+                    code: 'ICEBERG_IDENTIFIER_TYPE_PRIMITIVE',
+                    field,
+                    message: `identifier field "${name}" must be a primitive type other than float or double`,
+                }));
+            }
+        });
+        return violations;
+    }
+    /**
+     * Normalize a partition into its identity key. When the transform parses,
+     * collapse on `${kind}:${param}` so `day` and `DAY`, `bucket[16]` and
+     * `bucket[ 16 ]` are the same. When the transform doesn't parse, the
+     * lowercased trim of the raw string is the best identity we have.
+     *
+     * @param partition Partition to key.
+     * @returns The identity string for duplicate detection.
+     */
+    partitionKey(partition) {
+        const transform = (0, iceberg_1.parseIcebergTransform)(partition.type);
+        const normalizedTransform = transform
+            ? `${transform.kind}:${transform.param ?? ''}`
+            : partition.type.trim().toLowerCase();
+        return `${partition.name} ${normalizedTransform}`;
+    }
+}
+exports.IcebergParquetV2Table = IcebergParquetV2Table;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"iceberg-parquet-v2.js","sourceRoot":"","sources":["../../../src/table-types/iceberg-parquet-v2.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Iceberg (parquet) format-version-2 table type.\n *\n * Iceberg partitions are transforms applied to a data column, so duplicate\n * detection keys on the (source column, normalized transform) pair — `year(ts)`\n * and `month(ts)` are distinct, while `day` and `DAY` collapse.\n *\n * The format version is encoded in the `tableType` discriminator: this engine is\n * inherently v2, so a present `formatVersion` must equal `EXPECTED_FORMAT_VERSION`.\n * A future `iceberg_parquet_v3` sibling subclass overrides that one constant.\n */\n\nimport {\n    Partition,\n    SortField,\n    Violation,\n} from '../model';\nimport {\n    TableTypeBase,\n} from '../table-type';\nimport {\n    IcebergTypeKind,\n    isValidIcebergType,\n    parseIcebergTransform,\n    parseIcebergType,\n    transformLegalOnType,\n} from '../iceberg';\n\n/**\n * Whether a string is a positive integer (digits only, value > 0). Iceberg\n * table-property values are strings, so numeric checks parse the string.\n *\n * @param value Property value string.\n * @returns True when `value` is a positive integer.\n */\nfunction isPositiveInteger(value: string): boolean {\n    return /^\\d+$/.test(value) && Number(value) > 0;\n}\n\n/**\n * Whether a string is a non-negative integer (digits only, value >= 0).\n *\n * @param value Property value string.\n * @returns True when `value` is a non-negative integer.\n */\nfunction isNonNegativeInteger(value: string): boolean {\n    return /^\\d+$/.test(value);\n}\n\n/**\n * Whether a string is an integer within an inclusive range.\n *\n * @param value Property value string.\n * @param min Inclusive lower bound.\n * @param max Inclusive upper bound.\n * @returns True when `value` is an integer in `[min, max]`.\n */\nfunction isIntegerInRange(value: string, min: number, max: number): boolean {\n    if (!/^\\d+$/.test(value)) {\n        return false;\n    }\n    const parsed = Number(value);\n    return parsed >= min && parsed <= max;\n}\n\n/** Iceberg (parquet) format-version-2 table. */\nexport class IcebergParquetV2Table extends TableTypeBase {\n    /**\n     * The Iceberg format version this engine pins to. A present `formatVersion`\n     * must equal this. A future v3 sibling subclass overrides this single value.\n     */\n    protected static readonly EXPECTED_FORMAT_VERSION = 2;\n\n    /**\n     * Validate a column type against the Iceberg v0 type registry.\n     *\n     * @param type Type string from a column definition.\n     * @returns True when the type is a valid Iceberg type.\n     */\n    public isValidColumnType(type: string): boolean {\n        return isValidIcebergType(type);\n    }\n\n    /**\n     * Iceberg partition rules.\n     *\n     * Emits: `NO_DUPLICATE_PARTITIONS` (keyed by `${name} ${transformKind}:${param}`,\n     * falling back to a lowercased trim of the raw transform when it doesn't\n     * parse, so whitespace / case variants of the same transform collapse),\n     * `ICEBERG_TRANSFORM_SOURCE_EXISTS`, `ICEBERG_TRANSFORM_VALID`, and\n     * `ICEBERG_TRANSFORM_SOURCE_TYPE_LEGAL`.\n     *\n     * @returns Every partition-related violation.\n     */\n    public partitionViolations(): Violation[] {\n        const violations: Violation[] = [];\n        const {\n            partitions,\n        } = this.definition;\n\n        const seen = new Set<string>();\n        partitions.forEach((partition, index) => {\n            const key = this.partitionKey(partition);\n            if (seen.has(key)) {\n                violations.push(this.violation({\n                    level: 'error',\n                    code: 'NO_DUPLICATE_PARTITIONS',\n                    field: `partitions[${index}]`,\n                    message: `duplicate partition: \"${partition.name}\" with transform \"${partition.type}\"`,\n                }));\n            }\n            seen.add(key);\n        });\n\n        partitions.forEach((partition, index) => {\n            const sourceColumn = this.definition.columns.find((column) => column.name === partition.name);\n            if (sourceColumn === undefined) {\n                violations.push(this.violation({\n                    level: 'error',\n                    code: 'ICEBERG_TRANSFORM_SOURCE_EXISTS',\n                    field: `partitions[${index}].name`,\n                    message: `Iceberg partition source column \"${partition.name}\" is not defined in columns`,\n                }));\n                return;\n            }\n            const transform = parseIcebergTransform(partition.type);\n            if (transform === null) {\n                violations.push(this.violation({\n                    level: 'error',\n                    code: 'ICEBERG_TRANSFORM_VALID',\n                    field: `partitions[${index}].type`,\n                    message: `\"${partition.type}\" is not a valid Iceberg partition transform`,\n                }));\n                return;\n            }\n            const sourceType = parseIcebergType(sourceColumn.type);\n            if (sourceType !== null && !transformLegalOnType(transform, sourceType)) {\n                violations.push(this.violation({\n                    level: 'error',\n                    code: 'ICEBERG_TRANSFORM_SOURCE_TYPE_LEGAL',\n                    field: `partitions[${index}].type`,\n                    message: `transform \"${partition.type}\" is not legal on `\n                        + `column \"${partition.name}\" of type \"${sourceColumn.type}\"`,\n                }));\n            }\n        });\n\n        return violations;\n    }\n\n    /// Table-property keys whose value must come from a closed set.\n    private static readonly ENUM_PROPERTIES: Record<string, readonly string[]> = {\n        'write.format.default': [\n            'parquet',\n            'avro',\n            'orc',\n        ],\n        'write.parquet.compression-codec': [\n            'zstd',\n            'gzip',\n            'snappy',\n            'lz4',\n            'none',\n        ],\n        'write.avro.compression-codec': [\n            'gzip',\n            'zstd',\n            'snappy',\n            'uncompressed',\n        ],\n        'write.orc.compression-codec': [\n            'zstd',\n            'lz4',\n            'lzo',\n            'zlib',\n            'snappy',\n            'none',\n        ],\n        'write.distribution-mode': [\n            'none',\n            'hash',\n            'range',\n        ],\n        'write.metadata.compression-codec': [\n            'none',\n            'gzip',\n        ],\n    };\n\n    /// Table-property keys whose value must be a positive integer.\n    private static readonly POSITIVE_INT_PROPERTIES: readonly string[] = [\n        'write.target-file-size-bytes',\n        'history.expire.max-snapshot-age-ms',\n        'history.expire.min-snapshots-to-keep',\n        'history.expire.max-ref-age-ms',\n        'write.metadata.previous-versions-max',\n        'commit.retry.min-wait-ms',\n        'commit.retry.max-wait-ms',\n        'commit.retry.total-timeout-ms',\n    ];\n\n    /// Table-property keys whose value must be a non-negative integer.\n    private static readonly NON_NEGATIVE_INT_PROPERTIES: readonly string[] = [\n        'commit.retry.num-retries',\n    ];\n\n    /// Table-property keys whose value must be an integer within an inclusive range.\n    private static readonly INT_RANGE_PROPERTIES: Record<string, { min: number; max: number }> = {\n        'write.parquet.compression-level': {\n            min: 1,\n            max: 22,\n        },\n    };\n\n    /// Legal sort directions and null orderings.\n    private static readonly SORT_DIRECTIONS = new Set([\n        'asc',\n        'desc',\n    ]);\n\n    private static readonly SORT_NULL_ORDERS = new Set([\n        'nulls-first',\n        'nulls-last',\n    ]);\n\n    /**\n     * Iceberg engine-specific rules: format version, table properties, and sort\n     * order.\n     *\n     * @returns Every engine-specific violation.\n     */\n    public engineSpecificViolations(): Violation[] {\n        return [\n            ...this.formatVersionViolations(),\n            ...this.tablePropertyViolations(),\n            ...this.sortOrderViolations(),\n            ...this.identifierFieldViolations(),\n        ];\n    }\n\n    /**\n     * Validate the Iceberg sort order.\n     *\n     * Emits `NO_DUPLICATE_SORT_FIELDS` (keyed by source column + normalized\n     * transform), `ICEBERG_SORT_COLUMN_EXISTS`, `ICEBERG_SORT_DIRECTION_VALID`,\n     * `ICEBERG_SORT_NULL_ORDER_VALID`, `ICEBERG_SORT_TRANSFORM_VALID`, and\n     * `ICEBERG_SORT_TRANSFORM_TYPE_LEGAL`.\n     *\n     * @returns Every sort-order violation.\n     */\n    private sortOrderViolations(): Violation[] {\n        const violations: Violation[] = [];\n        const {\n            sortOrder,\n        } = this.definition;\n\n        const seen = new Set<string>();\n        sortOrder.forEach((field, index) => {\n            const key = this.sortFieldKey(field);\n            if (seen.has(key)) {\n                violations.push(this.violation({\n                    level: 'error',\n                    code: 'NO_DUPLICATE_SORT_FIELDS',\n                    field: `sortOrder[${index}]`,\n                    message: `duplicate sort field: \"${field.column}\"`\n                        + `${field.transform ? ` with transform \"${field.transform}\"` : ''}`,\n                }));\n            }\n            seen.add(key);\n        });\n\n        sortOrder.forEach((field, index) => {\n            if (!IcebergParquetV2Table.SORT_DIRECTIONS.has(field.direction)) {\n                violations.push(this.violation({\n                    level: 'error',\n                    code: 'ICEBERG_SORT_DIRECTION_VALID',\n                    field: `sortOrder[${index}].direction`,\n                    message: `sort direction \"${field.direction}\" must be \"asc\" or \"desc\"`,\n                }));\n            }\n            if (!IcebergParquetV2Table.SORT_NULL_ORDERS.has(field.nullOrder)) {\n                violations.push(this.violation({\n                    level: 'error',\n                    code: 'ICEBERG_SORT_NULL_ORDER_VALID',\n                    field: `sortOrder[${index}].nullOrder`,\n                    message: `sort null order \"${field.nullOrder}\" must be \"nulls-first\" or \"nulls-last\"`,\n                }));\n            }\n\n            const sourceColumn = this.definition.columns.find((column) => column.name === field.column);\n            if (sourceColumn === undefined) {\n                violations.push(this.violation({\n                    level: 'error',\n                    code: 'ICEBERG_SORT_COLUMN_EXISTS',\n                    field: `sortOrder[${index}].column`,\n                    message: `sort column \"${field.column}\" is not defined in columns`,\n                }));\n                return;\n            }\n\n            if (field.transform === undefined) {\n                return;\n            }\n            const transform = parseIcebergTransform(field.transform);\n            if (transform === null) {\n                violations.push(this.violation({\n                    level: 'error',\n                    code: 'ICEBERG_SORT_TRANSFORM_VALID',\n                    field: `sortOrder[${index}].transform`,\n                    message: `\"${field.transform}\" is not a valid Iceberg transform`,\n                }));\n                return;\n            }\n            const sourceType = parseIcebergType(sourceColumn.type);\n            if (sourceType !== null && !transformLegalOnType(transform, sourceType)) {\n                violations.push(this.violation({\n                    level: 'error',\n                    code: 'ICEBERG_SORT_TRANSFORM_TYPE_LEGAL',\n                    field: `sortOrder[${index}].transform`,\n                    message: `transform \"${field.transform}\" is not legal on `\n                        + `column \"${field.column}\" of type \"${sourceColumn.type}\"`,\n                }));\n            }\n        });\n\n        return violations;\n    }\n\n    /**\n     * Normalize a sort field into its identity key. An omitted transform and an\n     * explicit `identity` collapse to the same key so they count as duplicates.\n     *\n     * @param field Sort field to key.\n     * @returns The identity string for duplicate detection.\n     */\n    private sortFieldKey(field: SortField): string {\n        if (field.transform === undefined) {\n            return `${field.column} identity:`;\n        }\n        const transform = parseIcebergTransform(field.transform);\n        const normalizedTransform = transform\n            ? `${transform.kind}:${transform.param ?? ''}`\n            : field.transform.trim().toLowerCase();\n        return `${field.column} ${normalizedTransform}`;\n    }\n\n    /// ICEBERG_FORMAT_VERSION_VALID — `formatVersion`, when set, equals the\n    /// version this engine pins to (2 for `iceberg_parquet_v2`).\n    private formatVersionViolations(): Violation[] {\n        const {\n            formatVersion,\n        } = this.definition;\n        const expected = (this.constructor as typeof IcebergParquetV2Table).EXPECTED_FORMAT_VERSION;\n        if (formatVersion === undefined || formatVersion === expected) {\n            return [];\n        }\n        return [\n            this.violation({\n                level: 'error',\n                code: 'ICEBERG_FORMAT_VERSION_VALID',\n                field: 'formatVersion',\n                message: `Iceberg formatVersion \"${formatVersion}\" must be ${expected}`,\n            }),\n        ];\n    }\n\n    /**\n     * Validate the closed-domain Iceberg table properties. Keys outside the\n     * known set pass through unvalidated.\n     *\n     * Emits `ICEBERG_PROPERTY_ENUM_VALID`, `ICEBERG_PROPERTY_POSITIVE_INT`,\n     * `ICEBERG_PROPERTY_NON_NEGATIVE_INT`, `ICEBERG_PROPERTY_INT_RANGE`, and\n     * `ICEBERG_COMMIT_RETRY_ORDERING`.\n     *\n     * @returns Every table-property violation.\n     */\n    private tablePropertyViolations(): Violation[] {\n        const violations: Violation[] = [];\n        const properties = this.definition.tableProperties;\n\n        for (const [\n            key,\n            value,\n        ] of Object.entries(properties)) {\n            const allowed = IcebergParquetV2Table.ENUM_PROPERTIES[key];\n            if (allowed !== undefined && !allowed.includes(value)) {\n                violations.push(this.violation({\n                    level: 'error',\n                    code: 'ICEBERG_PROPERTY_ENUM_VALID',\n                    field: `tableProperties[\"${key}\"]`,\n                    message: `table property \"${key}\" value \"${value}\" must be one of: ${allowed.join(', ')}`,\n                }));\n            }\n\n            if (IcebergParquetV2Table.POSITIVE_INT_PROPERTIES.includes(key) && !isPositiveInteger(value)) {\n                violations.push(this.violation({\n                    level: 'error',\n                    code: 'ICEBERG_PROPERTY_POSITIVE_INT',\n                    field: `tableProperties[\"${key}\"]`,\n                    message: `table property \"${key}\" value \"${value}\" must be a positive integer`,\n                }));\n            }\n\n            if (IcebergParquetV2Table.NON_NEGATIVE_INT_PROPERTIES.includes(key) && !isNonNegativeInteger(value)) {\n                violations.push(this.violation({\n                    level: 'error',\n                    code: 'ICEBERG_PROPERTY_NON_NEGATIVE_INT',\n                    field: `tableProperties[\"${key}\"]`,\n                    message: `table property \"${key}\" value \"${value}\" must be a non-negative integer`,\n                }));\n            }\n\n            const range = IcebergParquetV2Table.INT_RANGE_PROPERTIES[key];\n            if (range !== undefined && !isIntegerInRange(value, range.min, range.max)) {\n                violations.push(this.violation({\n                    level: 'error',\n                    code: 'ICEBERG_PROPERTY_INT_RANGE',\n                    field: `tableProperties[\"${key}\"]`,\n                    message: `table property \"${key}\" value \"${value}\" must be an integer between `\n                        + `${range.min} and ${range.max}`,\n                }));\n            }\n        }\n\n        violations.push(...this.commitRetryOrderingViolations(properties));\n\n        return violations;\n    }\n\n    /// ICEBERG_COMMIT_RETRY_ORDERING — commit.retry waits obey\n    /// min-wait-ms <= max-wait-ms <= total-timeout-ms when all are positive ints.\n    private commitRetryOrderingViolations(properties: Record<string, string>): Violation[] {\n        const values = [\n            properties['commit.retry.min-wait-ms'],\n            properties['commit.retry.max-wait-ms'],\n            properties['commit.retry.total-timeout-ms'],\n        ];\n        if (!values.every((value) => value !== undefined && isPositiveInteger(value))) {\n            return [];\n        }\n        const [\n            min,\n            max,\n            total,\n        ] = values.map(Number);\n        if (min <= max && max <= total) {\n            return [];\n        }\n        return [\n            this.violation({\n                level: 'error',\n                code: 'ICEBERG_COMMIT_RETRY_ORDERING',\n                field: 'tableProperties[\"commit.retry.min-wait-ms\"]',\n                message: 'commit.retry waits must satisfy min-wait-ms <= max-wait-ms <= total-timeout-ms',\n            }),\n        ];\n    }\n\n    /**\n     * Validate Iceberg identifier fields (the row-identity / equality-delete\n     * key). Equality deletes are a v2 feature, which this engine inherently is;\n     * identifier fields must be required primitive columns that are not\n     * float/double.\n     *\n     * Emits `ICEBERG_IDENTIFIER_COLUMN_EXISTS`, `ICEBERG_IDENTIFIER_REQUIRED`,\n     * and `ICEBERG_IDENTIFIER_TYPE_PRIMITIVE`.\n     *\n     * @returns Every identifier-field violation.\n     */\n    private identifierFieldViolations(): Violation[] {\n        const violations: Violation[] = [];\n        const {\n            identifierFields,\n        } = this.definition;\n\n        if (identifierFields.length === 0) {\n            return [];\n        }\n\n        identifierFields.forEach((name, index) => {\n            const field = `identifierFields[${index}]`;\n            const column = this.definition.columns.find((candidate) => candidate.name === name);\n            if (column === undefined) {\n                violations.push(this.violation({\n                    level: 'error',\n                    code: 'ICEBERG_IDENTIFIER_COLUMN_EXISTS',\n                    field,\n                    message: `identifier field \"${name}\" is not defined in columns`,\n                }));\n                return;\n            }\n            if (column.nullable === true) {\n                violations.push(this.violation({\n                    level: 'error',\n                    code: 'ICEBERG_IDENTIFIER_REQUIRED',\n                    field,\n                    message: `identifier field \"${name}\" must be required (nullable: false)`,\n                }));\n            }\n            const type = parseIcebergType(column.type);\n            if (type === null || type.kind === IcebergTypeKind.FLOAT || type.kind === IcebergTypeKind.DOUBLE) {\n                violations.push(this.violation({\n                    level: 'error',\n                    code: 'ICEBERG_IDENTIFIER_TYPE_PRIMITIVE',\n                    field,\n                    message: `identifier field \"${name}\" must be a primitive type other than float or double`,\n                }));\n            }\n        });\n\n        return violations;\n    }\n\n    /**\n     * Normalize a partition into its identity key. When the transform parses,\n     * collapse on `${kind}:${param}` so `day` and `DAY`, `bucket[16]` and\n     * `bucket[ 16 ]` are the same. When the transform doesn't parse, the\n     * lowercased trim of the raw string is the best identity we have.\n     *\n     * @param partition Partition to key.\n     * @returns The identity string for duplicate detection.\n     */\n    private partitionKey(partition: Partition): string {\n        const transform = parseIcebergTransform(partition.type);\n        const normalizedTransform = transform\n            ? `${transform.kind}:${transform.param ?? ''}`\n            : partition.type.trim().toLowerCase();\n        return `${partition.name} ${normalizedTransform}`;\n    }\n}\n"]}

package/dist/src/table-types/registry.js

@@ -8,12 +8,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTableType = createTableType;
 const model_1 = require("../model");
 const hive_parquet_1 = require("./hive-parquet");
-const iceberg_parquet_1 = require("./iceberg-parquet");
+const iceberg_parquet_v2_1 = require("./iceberg-parquet-v2");
 const postgres_18_1 = require("./postgres-18");
 /// Exhaustive map: every value of the `TableType` enum has a concrete subclass.
 const REGISTRY = {
     [model_1.TableType.HIVE_PARQUET]: hive_parquet_1.HiveParquetTable,
-    [model_1.TableType.ICEBERG_PARQUET]: iceberg_parquet_1.IcebergParquetTable,
+    [model_1.TableType.ICEBERG_PARQUET_V2]: iceberg_parquet_v2_1.IcebergParquetV2Table,
     [model_1.TableType.POSTGRES_18]: postgres_18_1.Postgres18Table,
 };
 /**
@@ -33,4 +33,4 @@ function createTableType(fields) {
     const Constructor = REGISTRY[tableType] ?? hive_parquet_1.HiveParquetTable;
     return new Constructor(fields);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVnaXN0cnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdGFibGUtdHlwZXMvcmVnaXN0cnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7O0dBSUc7O0FBbUNILDBDQVVDO0FBM0NELG9DQUVrQjtBQUtsQixpREFFd0I7QUFDeEIsNkRBRThCO0FBQzlCLCtDQUV1QjtBQUt2QixnRkFBZ0Y7QUFDaEYsTUFBTSxRQUFRLEdBQTRDO0lBQ3RELENBQUMsaUJBQVMsQ0FBQyxZQUFZLENBQUMsRUFBRSwrQkFBZ0I7SUFDMUMsQ0FBQyxpQkFBUyxDQUFDLGtCQUFrQixDQUFDLEVBQUUsMENBQXFCO0lBQ3JELENBQUMsaUJBQVMsQ0FBQyxXQUFXLENBQUMsRUFBRSw2QkFBZTtDQUMzQyxDQUFDO0FBRUY7Ozs7O0dBS0c7QUFDSCxTQUFnQixlQUFlLENBQUMsTUFBdUI7SUFDbkQsTUFBTSxTQUFTLEdBQUcsTUFBTSxDQUFDLFVBQVUsQ0FBQyxTQUFzQixDQUFDO0lBQzNELDRFQUE0RTtJQUM1RSx3RUFBd0U7SUFDeEUsMEVBQTBFO0lBQzFFLDJFQUEyRTtJQUMzRSx5RUFBeUU7SUFDekUsNkJBQTZCO0lBQzdCLE1BQU0sV0FBVyxHQUFHLFFBQVEsQ0FBQyxTQUFTLENBQUMsSUFBSSwrQkFBZ0IsQ0FBQztJQUM1RCxPQUFPLElBQUksV0FBVyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0FBQ25DLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFJlZ2lzdHJ5IG1hcHBpbmcgdGhlIGB0YWJsZVR5cGVgIHN0cmluZyB0byB0aGUgY29uY3JldGUgYFRhYmxlVHlwZUJhc2VgXG4gKiBzdWJjbGFzcyB0aGF0IGltcGxlbWVudHMgaXQuIEFkZGluZyBhIG5ldyBlbmdpbmUgaXMgYSBtYXR0ZXIgb2Ygd3JpdGluZyBhXG4gKiBzdWJjbGFzcyBhbmQgYWRkaW5nIG9uZSBlbnRyeSBoZXJlLlxuICovXG5cbmltcG9ydCB7XG4gICAgVGFibGVUeXBlLFxufSBmcm9tICcuLi9tb2RlbCc7XG5pbXBvcnQge1xuICAgIFRhYmxlVHlwZUJhc2UsXG4gICAgVGFibGVUeXBlRmllbGRzLFxufSBmcm9tICcuLi90YWJsZS10eXBlJztcbmltcG9ydCB7XG4gICAgSGl2ZVBhcnF1ZXRUYWJsZSxcbn0gZnJvbSAnLi9oaXZlLXBhcnF1ZXQnO1xuaW1wb3J0IHtcbiAgICBJY2ViZXJnUGFycXVldFYyVGFibGUsXG59IGZyb20gJy4vaWNlYmVyZy1wYXJxdWV0LXYyJztcbmltcG9ydCB7XG4gICAgUG9zdGdyZXMxOFRhYmxlLFxufSBmcm9tICcuL3Bvc3RncmVzLTE4JztcblxuLyoqIENvbnN0cnVjdG9yIHNpZ25hdHVyZSBzaGFyZWQgYnkgZXZlcnkgY29uY3JldGUgdGFibGUgc3ViY2xhc3MuICovXG50eXBlIFRhYmxlVHlwZUNvbnN0cnVjdG9yID0gbmV3IChmaWVsZHM6IFRhYmxlVHlwZUZpZWxkcykgPT4gVGFibGVUeXBlQmFzZTtcblxuLy8vIEV4aGF1c3RpdmUgbWFwOiBldmVyeSB2YWx1ZSBvZiB0aGUgYFRhYmxlVHlwZWAgZW51bSBoYXMgYSBjb25jcmV0ZSBzdWJjbGFzcy5cbmNvbnN0IFJFR0lTVFJZOiBSZWNvcmQ8VGFibGVUeXBlLCBUYWJsZVR5cGVDb25zdHJ1Y3Rvcj4gPSB7XG4gICAgW1RhYmxlVHlwZS5ISVZFX1BBUlFVRVRdOiBIaXZlUGFycXVldFRhYmxlLFxuICAgIFtUYWJsZVR5cGUuSUNFQkVSR19QQVJRVUVUX1YyXTogSWNlYmVyZ1BhcnF1ZXRWMlRhYmxlLFxuICAgIFtUYWJsZVR5cGUuUE9TVEdSRVNfMThdOiBQb3N0Z3JlczE4VGFibGUsXG59O1xuXG4vKipcbiAqIEJ1aWxkIHRoZSBjb25jcmV0ZSBgVGFibGVUeXBlQmFzZWAgc3ViY2xhc3MgZm9yIHRoZSBnaXZlbiBmaWVsZHMuXG4gKlxuICogQHBhcmFtIGZpZWxkcyBUaGUgbm9ybWFsaXplZCB0YWJsZSBmaWVsZHMuXG4gKiBAcmV0dXJucyBBIGNvbmNyZXRlIHRhYmxlIGluc3RhbmNlIGZvciB0aGUgZW5naW5lIG5hbWVkIGJ5IGBmaWVsZHMuZGVmaW5pdGlvbi50YWJsZVR5cGVgLlxuICovXG5leHBvcnQgZnVuY3Rpb24gY3JlYXRlVGFibGVUeXBlKGZpZWxkczogVGFibGVUeXBlRmllbGRzKTogVGFibGVUeXBlQmFzZSB7XG4gICAgY29uc3QgdGFibGVUeXBlID0gZmllbGRzLmRlZmluaXRpb24udGFibGVUeXBlIGFzIFRhYmxlVHlwZTtcbiAgICAvLy8gQW4gdW5yZWNvZ25pemVkIGB0YWJsZVR5cGVgIG9ubHkgb2NjdXJzIHdoZW4gTGF5ZXIgMSBhbHJlYWR5IGZsYWdnZWQgdGhlXG4gICAgLy8vIGZpbGU6IHN1Y2ggdGFibGVzIGFyZSBza2lwcGVkIGJ5IGludHJhLXRhYmxlIHJ1bGVzIGFuZCBza2lwcGVkIGFzIEZLXG4gICAgLy8vIHRhcmdldHMsIHNvIHRoZSBjaG9pY2UgaGVyZSBpcyBwdXJlbHkgZm9yIGNyb3NzLWZpbGUgKnJlc29sdXRpb24qICh0aGVcbiAgICAvLy8gaW5zdGFuY2Ugc3RpbGwgbmVlZHMgdG8gbGFuZCBpbiBgd29ybGQudGFibGVzYCBzbyBkZXBlbmRzT24gLyBGSyBzb3VyY2VcbiAgICAvLy8gbG9va3VwcyBkb24ndCBwcmV0ZW5kIHRoZSBmaWxlIGlzIG1pc3NpbmcpLiBgSGl2ZVBhcnF1ZXRUYWJsZWAgaXMgdGhlXG4gICAgLy8vIHJlc29sdXRpb24tb25seSBmYWxsYmFjay5cbiAgICBjb25zdCBDb25zdHJ1Y3RvciA9IFJFR0lTVFJZW3RhYmxlVHlwZV0gPz8gSGl2ZVBhcnF1ZXRUYWJsZTtcbiAgICByZXR1cm4gbmV3IENvbnN0cnVjdG9yKGZpZWxkcyk7XG59XG4iXX0=

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "flexdataset",
-    "version": "0.21.1",
+    "version": "0.22.0",
     "license": "Apache-2.0",
     "description": "Flexible Dataset Definition (FDD) — validator and tooling for the FDD dataset standard.",
     "author": "Rodrigo Carvajal",
@@ -53,7 +53,7 @@
     "devDependencies": {
         "@eslint/js": "^9.27.0",
         "@types/jest": "^29.5.14",
-        "@types/node": "22.7.9",
+        "@types/node": "^24.13.2",
         "@typescript-eslint/eslint-plugin": "^8.0.0",
         "@typescript-eslint/parser": "^8.0.0",
         "eslint": "^9.27.0",
@@ -63,6 +63,9 @@
         "ts-jest": "^29.2.5",
         "typescript": "~5.6.3"
     },
+    "engines": {
+        "node": ">=22.14"
+    },
     "publishConfig": {
         "access": "public"
     }