flexdataset 0.4.1

package/dist/src/diagram/render.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Thin wrapper over the WASM Graphviz engine. Kept separate from the DOT
+ * builders so the (pure, deterministic) DOT generation can be unit-tested
+ * without loading WASM.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderDot = renderDot;
+/**
+ * Render a Graphviz DOT document to SVG.
+ *
+ * `@hpcc-js/wasm-graphviz` is ESM-only, so it is pulled in via a dynamic import
+ * (preserved by the NodeNext target and resolvable from this CommonJS module at
+ * runtime) rather than a static import.
+ *
+ * @param dot A DOT document.
+ * @returns The rendered SVG markup.
+ */
+async function renderDot(dot) {
+    const { Graphviz, } = await import('@hpcc-js/wasm-graphviz');
+    const graphviz = await Graphviz.load();
+    return graphviz.dot(dot);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVuZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2RpYWdyYW0vcmVuZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7OztHQUlHOztBQVlILDhCQU1DO0FBaEJEOzs7Ozs7Ozs7R0FTRztBQUNJLEtBQUssVUFBVSxTQUFTLENBQUMsR0FBVztJQUN2QyxNQUFNLEVBQ0YsUUFBUSxHQUNYLEdBQUcsTUFBTSxNQUFNLENBQUMsd0JBQXdCLENBQUMsQ0FBQztJQUMzQyxNQUFNLFFBQVEsR0FBRyxNQUFNLFFBQVEsQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUN2QyxPQUFPLFFBQVEsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUM7QUFDN0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogVGhpbiB3cmFwcGVyIG92ZXIgdGhlIFdBU00gR3JhcGh2aXogZW5naW5lLiBLZXB0IHNlcGFyYXRlIGZyb20gdGhlIERPVFxuICogYnVpbGRlcnMgc28gdGhlIChwdXJlLCBkZXRlcm1pbmlzdGljKSBET1QgZ2VuZXJhdGlvbiBjYW4gYmUgdW5pdC10ZXN0ZWRcbiAqIHdpdGhvdXQgbG9hZGluZyBXQVNNLlxuICovXG5cbi8qKlxuICogUmVuZGVyIGEgR3JhcGh2aXogRE9UIGRvY3VtZW50IHRvIFNWRy5cbiAqXG4gKiBgQGhwY2MtanMvd2FzbS1ncmFwaHZpemAgaXMgRVNNLW9ubHksIHNvIGl0IGlzIHB1bGxlZCBpbiB2aWEgYSBkeW5hbWljIGltcG9ydFxuICogKHByZXNlcnZlZCBieSB0aGUgTm9kZU5leHQgdGFyZ2V0IGFuZCByZXNvbHZhYmxlIGZyb20gdGhpcyBDb21tb25KUyBtb2R1bGUgYXRcbiAqIHJ1bnRpbWUpIHJhdGhlciB0aGFuIGEgc3RhdGljIGltcG9ydC5cbiAqXG4gKiBAcGFyYW0gZG90IEEgRE9UIGRvY3VtZW50LlxuICogQHJldHVybnMgVGhlIHJlbmRlcmVkIFNWRyBtYXJrdXAuXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiByZW5kZXJEb3QoZG90OiBzdHJpbmcpOiBQcm9taXNlPHN0cmluZz4ge1xuICAgIGNvbnN0IHtcbiAgICAgICAgR3JhcGh2aXosIFxuICAgIH0gPSBhd2FpdCBpbXBvcnQoJ0BocGNjLWpzL3dhc20tZ3JhcGh2aXonKTtcbiAgICBjb25zdCBncmFwaHZpeiA9IGF3YWl0IEdyYXBodml6LmxvYWQoKTtcbiAgICByZXR1cm4gZ3JhcGh2aXouZG90KGRvdCk7XG59XG4iXX0=

package/dist/src/iceberg.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Iceberg type and partition-transform parsing and legality.
+ *
+ * Ported from the arceus repo (`lib/iceberg/iceberg-type.ts`,
+ * `lib/iceberg/iceberg-partition-transform.ts`). arceus models types as
+ * constructed objects and *throws* on the first problem because it is a CDK
+ * construct; FDD instead parses the *string* type found in a JSON file and
+ * returns structured results so the validator can collect every violation.
+ *
+ * v0 supports Iceberg primitives plus the parameterized `decimal(p,s)` and
+ * `fixed[L]`. Nested `list`/`map`/`struct` types are deferred to a later
+ * version; partition transforms only apply to primitive source types anyway.
+ */
+/** Iceberg primitive / parameterized type kinds supported in v0. */
+export declare enum IcebergTypeKind {
+    BOOLEAN = "boolean",
+    INT = "int",
+    LONG = "long",
+    FLOAT = "float",
+    DOUBLE = "double",
+    DATE = "date",
+    TIME = "time",
+    TIMESTAMP = "timestamp",
+    TIMESTAMPTZ = "timestamptz",
+    STRING = "string",
+    UUID = "uuid",
+    BINARY = "binary",
+    DECIMAL = "decimal",
+    FIXED = "fixed"
+}
+/** A parsed Iceberg type. */
+export interface IcebergType {
+    /** Discriminator. */
+    readonly kind: IcebergTypeKind;
+    /** Decimal precision (set when `kind === DECIMAL`). */
+    readonly decimalPrecision?: number;
+    /** Decimal scale (set when `kind === DECIMAL`). */
+    readonly decimalScale?: number;
+    /** Fixed byte length (set when `kind === FIXED`). */
+    readonly fixedLength?: number;
+}
+/**
+ * Parse an Iceberg type string into a structured type. Matching is
+ * case-insensitive, consistent with the Hive and Postgres registries.
+ *
+ * @param typeStr Type string from a column definition.
+ * @returns The parsed type, or null if it is not a valid v0 Iceberg type.
+ */
+export declare function parseIcebergType(typeStr: string): IcebergType | null;
+/** Whether the string is a valid v0 Iceberg column type. */
+export declare function isValidIcebergType(typeStr: string): boolean;
+/** Iceberg partition-transform kinds. */
+export declare enum IcebergTransformKind {
+    IDENTITY = "identity",
+    YEAR = "year",
+    MONTH = "month",
+    DAY = "day",
+    HOUR = "hour",
+    VOID = "void",
+    BUCKET = "bucket",
+    TRUNCATE = "truncate"
+}
+/** A parsed Iceberg partition transform. */
+export interface IcebergTransform {
+    /** Discriminator. */
+    readonly kind: IcebergTransformKind;
+    /** Parameter for `bucket[N]` / `truncate[W]` (positive integer). */
+    readonly param?: number;
+}
+/**
+ * Parse an Iceberg transform string. Matching is case-insensitive.
+ *
+ * @param transformStr Transform string from a partition definition.
+ * @returns The parsed transform, or null if it is not a valid transform.
+ */
+export declare function parseIcebergTransform(transformStr: string): IcebergTransform | null;
+/**
+ * Whether a transform is legal on a given source-column type. Mirrors arceus's
+ * `IcebergPartitionTransform.validateSourceType`.
+ *
+ * @param transform Parsed transform.
+ * @param sourceType Parsed source-column type.
+ * @returns True when the transform may be applied to that type.
+ */
+export declare function transformLegalOnType(transform: IcebergTransform, sourceType: IcebergType): boolean;

package/dist/src/iceberg.js

@@ -0,0 +1,221 @@
+"use strict";
+/**
+ * Iceberg type and partition-transform parsing and legality.
+ *
+ * Ported from the arceus repo (`lib/iceberg/iceberg-type.ts`,
+ * `lib/iceberg/iceberg-partition-transform.ts`). arceus models types as
+ * constructed objects and *throws* on the first problem because it is a CDK
+ * construct; FDD instead parses the *string* type found in a JSON file and
+ * returns structured results so the validator can collect every violation.
+ *
+ * v0 supports Iceberg primitives plus the parameterized `decimal(p,s)` and
+ * `fixed[L]`. Nested `list`/`map`/`struct` types are deferred to a later
+ * version; partition transforms only apply to primitive source types anyway.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IcebergTransformKind = exports.IcebergTypeKind = void 0;
+exports.parseIcebergType = parseIcebergType;
+exports.isValidIcebergType = isValidIcebergType;
+exports.parseIcebergTransform = parseIcebergTransform;
+exports.transformLegalOnType = transformLegalOnType;
+/** Iceberg primitive / parameterized type kinds supported in v0. */
+var IcebergTypeKind;
+(function (IcebergTypeKind) {
+    IcebergTypeKind["BOOLEAN"] = "boolean";
+    IcebergTypeKind["INT"] = "int";
+    IcebergTypeKind["LONG"] = "long";
+    IcebergTypeKind["FLOAT"] = "float";
+    IcebergTypeKind["DOUBLE"] = "double";
+    IcebergTypeKind["DATE"] = "date";
+    IcebergTypeKind["TIME"] = "time";
+    IcebergTypeKind["TIMESTAMP"] = "timestamp";
+    IcebergTypeKind["TIMESTAMPTZ"] = "timestamptz";
+    IcebergTypeKind["STRING"] = "string";
+    IcebergTypeKind["UUID"] = "uuid";
+    IcebergTypeKind["BINARY"] = "binary";
+    IcebergTypeKind["DECIMAL"] = "decimal";
+    IcebergTypeKind["FIXED"] = "fixed";
+})(IcebergTypeKind || (exports.IcebergTypeKind = IcebergTypeKind = {}));
+const ICEBERG_PRIMITIVES = [
+    IcebergTypeKind.BOOLEAN,
+    IcebergTypeKind.INT,
+    IcebergTypeKind.LONG,
+    IcebergTypeKind.FLOAT,
+    IcebergTypeKind.DOUBLE,
+    IcebergTypeKind.DATE,
+    IcebergTypeKind.TIME,
+    IcebergTypeKind.TIMESTAMP,
+    IcebergTypeKind.TIMESTAMPTZ,
+    IcebergTypeKind.STRING,
+    IcebergTypeKind.UUID,
+    IcebergTypeKind.BINARY,
+];
+const DECIMAL_RE = /^decimal\(\s*(\d+)\s*,\s*(\d+)\s*\)$/;
+const FIXED_RE = /^fixed\[\s*(\d+)\s*\]$/;
+/**
+ * Parse an Iceberg type string into a structured type. Matching is
+ * case-insensitive, consistent with the Hive and Postgres registries.
+ *
+ * @param typeStr Type string from a column definition.
+ * @returns The parsed type, or null if it is not a valid v0 Iceberg type.
+ */
+function parseIcebergType(typeStr) {
+    const trimmed = typeStr.trim().toLowerCase();
+    if (ICEBERG_PRIMITIVES.includes(trimmed)) {
+        return {
+            kind: trimmed,
+        };
+    }
+    const decimalMatch = DECIMAL_RE.exec(trimmed);
+    if (decimalMatch) {
+        const precision = Number(decimalMatch[1]);
+        const scale = Number(decimalMatch[2]);
+        if (precision < 1 || precision > 38 || scale > precision) {
+            return null;
+        }
+        return {
+            kind: IcebergTypeKind.DECIMAL,
+            decimalPrecision: precision,
+            decimalScale: scale,
+        };
+    }
+    const fixedMatch = FIXED_RE.exec(trimmed);
+    if (fixedMatch) {
+        const length = Number(fixedMatch[1]);
+        if (length < 1) {
+            return null;
+        }
+        return {
+            kind: IcebergTypeKind.FIXED,
+            fixedLength: length,
+        };
+    }
+    return null;
+}
+/** Whether the string is a valid v0 Iceberg column type. */
+function isValidIcebergType(typeStr) {
+    return parseIcebergType(typeStr) !== null;
+}
+/** Iceberg partition-transform kinds. */
+var IcebergTransformKind;
+(function (IcebergTransformKind) {
+    IcebergTransformKind["IDENTITY"] = "identity";
+    IcebergTransformKind["YEAR"] = "year";
+    IcebergTransformKind["MONTH"] = "month";
+    IcebergTransformKind["DAY"] = "day";
+    IcebergTransformKind["HOUR"] = "hour";
+    IcebergTransformKind["VOID"] = "void";
+    IcebergTransformKind["BUCKET"] = "bucket";
+    IcebergTransformKind["TRUNCATE"] = "truncate";
+})(IcebergTransformKind || (exports.IcebergTransformKind = IcebergTransformKind = {}));
+const NULLARY_TRANSFORMS = [
+    IcebergTransformKind.IDENTITY,
+    IcebergTransformKind.YEAR,
+    IcebergTransformKind.MONTH,
+    IcebergTransformKind.DAY,
+    IcebergTransformKind.HOUR,
+    IcebergTransformKind.VOID,
+];
+const BUCKET_RE = /^bucket\[\s*(\d+)\s*\]$/;
+const TRUNCATE_RE = /^truncate\[\s*(\d+)\s*\]$/;
+/**
+ * Parse an Iceberg transform string. Matching is case-insensitive.
+ *
+ * @param transformStr Transform string from a partition definition.
+ * @returns The parsed transform, or null if it is not a valid transform.
+ */
+function parseIcebergTransform(transformStr) {
+    const trimmed = transformStr.trim().toLowerCase();
+    if (NULLARY_TRANSFORMS.includes(trimmed)) {
+        return {
+            kind: trimmed,
+        };
+    }
+    const bucketMatch = BUCKET_RE.exec(trimmed);
+    if (bucketMatch) {
+        const param = Number(bucketMatch[1]);
+        if (param < 1) {
+            return null;
+        }
+        return {
+            kind: IcebergTransformKind.BUCKET,
+            param,
+        };
+    }
+    const truncateMatch = TRUNCATE_RE.exec(trimmed);
+    if (truncateMatch) {
+        const param = Number(truncateMatch[1]);
+        if (param < 1) {
+            return null;
+        }
+        return {
+            kind: IcebergTransformKind.TRUNCATE,
+            param,
+        };
+    }
+    return null;
+}
+function isTemporal(kind) {
+    return kind === IcebergTypeKind.DATE
+        || kind === IcebergTypeKind.TIMESTAMP
+        || kind === IcebergTypeKind.TIMESTAMPTZ;
+}
+function isTimestamp(kind) {
+    return kind === IcebergTypeKind.TIMESTAMP
+        || kind === IcebergTypeKind.TIMESTAMPTZ;
+}
+const BUCKET_LEGAL = new Set([
+    IcebergTypeKind.INT,
+    IcebergTypeKind.LONG,
+    IcebergTypeKind.DATE,
+    IcebergTypeKind.TIME,
+    IcebergTypeKind.TIMESTAMP,
+    IcebergTypeKind.TIMESTAMPTZ,
+    IcebergTypeKind.STRING,
+    IcebergTypeKind.UUID,
+    IcebergTypeKind.BINARY,
+    IcebergTypeKind.DECIMAL,
+    IcebergTypeKind.FIXED,
+]);
+const TRUNCATE_LEGAL = new Set([
+    IcebergTypeKind.INT,
+    IcebergTypeKind.LONG,
+    IcebergTypeKind.STRING,
+    IcebergTypeKind.BINARY,
+    IcebergTypeKind.DECIMAL,
+]);
+function isBucketLegal(kind) {
+    return BUCKET_LEGAL.has(kind);
+}
+function isTruncateLegal(kind) {
+    return TRUNCATE_LEGAL.has(kind);
+}
+/**
+ * Whether a transform is legal on a given source-column type. Mirrors arceus's
+ * `IcebergPartitionTransform.validateSourceType`.
+ *
+ * @param transform Parsed transform.
+ * @param sourceType Parsed source-column type.
+ * @returns True when the transform may be applied to that type.
+ */
+function transformLegalOnType(transform, sourceType) {
+    switch (transform.kind) {
+        case IcebergTransformKind.IDENTITY:
+        case IcebergTransformKind.VOID:
+            return true;
+        case IcebergTransformKind.YEAR:
+        case IcebergTransformKind.MONTH:
+        case IcebergTransformKind.DAY:
+            return isTemporal(sourceType.kind);
+        case IcebergTransformKind.HOUR:
+            return isTimestamp(sourceType.kind);
+        case IcebergTransformKind.BUCKET:
+            return isBucketLegal(sourceType.kind);
+        case IcebergTransformKind.TRUNCATE:
+            return isTruncateLegal(sourceType.kind);
+        /* istanbul ignore next: exhaustive — every kind is handled above */
+        default:
+            return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"iceberg.js","sourceRoot":"","sources":["../../src/iceberg.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Iceberg type and partition-transform parsing and legality.\n *\n * Ported from the arceus repo (`lib/iceberg/iceberg-type.ts`,\n * `lib/iceberg/iceberg-partition-transform.ts`). arceus models types as\n * constructed objects and *throws* on the first problem because it is a CDK\n * construct; FDD instead parses the *string* type found in a JSON file and\n * returns structured results so the validator can collect every violation.\n *\n * v0 supports Iceberg primitives plus the parameterized `decimal(p,s)` and\n * `fixed[L]`. Nested `list`/`map`/`struct` types are deferred to a later\n * version; partition transforms only apply to primitive source types anyway.\n */\n\n/** Iceberg primitive / parameterized type kinds supported in v0. */\nexport enum IcebergTypeKind {\n    BOOLEAN = 'boolean',\n    INT = 'int',\n    LONG = 'long',\n    FLOAT = 'float',\n    DOUBLE = 'double',\n    DATE = 'date',\n    TIME = 'time',\n    TIMESTAMP = 'timestamp',\n    TIMESTAMPTZ = 'timestamptz',\n    STRING = 'string',\n    UUID = 'uuid',\n    BINARY = 'binary',\n    DECIMAL = 'decimal',\n    FIXED = 'fixed',\n}\n\nconst ICEBERG_PRIMITIVES: readonly IcebergTypeKind[] = [\n    IcebergTypeKind.BOOLEAN,\n    IcebergTypeKind.INT,\n    IcebergTypeKind.LONG,\n    IcebergTypeKind.FLOAT,\n    IcebergTypeKind.DOUBLE,\n    IcebergTypeKind.DATE,\n    IcebergTypeKind.TIME,\n    IcebergTypeKind.TIMESTAMP,\n    IcebergTypeKind.TIMESTAMPTZ,\n    IcebergTypeKind.STRING,\n    IcebergTypeKind.UUID,\n    IcebergTypeKind.BINARY,\n];\n\n/** A parsed Iceberg type. */\nexport interface IcebergType {\n    /** Discriminator. */\n    readonly kind: IcebergTypeKind;\n\n    /** Decimal precision (set when `kind === DECIMAL`). */\n    readonly decimalPrecision?: number;\n\n    /** Decimal scale (set when `kind === DECIMAL`). */\n    readonly decimalScale?: number;\n\n    /** Fixed byte length (set when `kind === FIXED`). */\n    readonly fixedLength?: number;\n}\n\nconst DECIMAL_RE = /^decimal\\(\\s*(\\d+)\\s*,\\s*(\\d+)\\s*\\)$/;\nconst FIXED_RE = /^fixed\\[\\s*(\\d+)\\s*\\]$/;\n\n/**\n * Parse an Iceberg type string into a structured type. Matching is\n * case-insensitive, consistent with the Hive and Postgres registries.\n *\n * @param typeStr Type string from a column definition.\n * @returns The parsed type, or null if it is not a valid v0 Iceberg type.\n */\nexport function parseIcebergType(typeStr: string): IcebergType | null {\n    const trimmed = typeStr.trim().toLowerCase();\n\n    if ((ICEBERG_PRIMITIVES as string[]).includes(trimmed)) {\n        return {\n            kind: trimmed as IcebergTypeKind,\n        };\n    }\n\n    const decimalMatch = DECIMAL_RE.exec(trimmed);\n    if (decimalMatch) {\n        const precision = Number(decimalMatch[1]);\n        const scale = Number(decimalMatch[2]);\n        if (precision < 1 || precision > 38 || scale > precision) {\n            return null;\n        }\n        return {\n            kind: IcebergTypeKind.DECIMAL,\n            decimalPrecision: precision,\n            decimalScale: scale,\n        };\n    }\n\n    const fixedMatch = FIXED_RE.exec(trimmed);\n    if (fixedMatch) {\n        const length = Number(fixedMatch[1]);\n        if (length < 1) {\n            return null;\n        }\n        return {\n            kind: IcebergTypeKind.FIXED,\n            fixedLength: length,\n        };\n    }\n\n    return null;\n}\n\n/** Whether the string is a valid v0 Iceberg column type. */\nexport function isValidIcebergType(typeStr: string): boolean {\n    return parseIcebergType(typeStr) !== null;\n}\n\n/** Iceberg partition-transform kinds. */\nexport enum IcebergTransformKind {\n    IDENTITY = 'identity',\n    YEAR = 'year',\n    MONTH = 'month',\n    DAY = 'day',\n    HOUR = 'hour',\n    VOID = 'void',\n    BUCKET = 'bucket',\n    TRUNCATE = 'truncate',\n}\n\nconst NULLARY_TRANSFORMS: readonly IcebergTransformKind[] = [\n    IcebergTransformKind.IDENTITY,\n    IcebergTransformKind.YEAR,\n    IcebergTransformKind.MONTH,\n    IcebergTransformKind.DAY,\n    IcebergTransformKind.HOUR,\n    IcebergTransformKind.VOID,\n];\n\n/** A parsed Iceberg partition transform. */\nexport interface IcebergTransform {\n    /** Discriminator. */\n    readonly kind: IcebergTransformKind;\n\n    /** Parameter for `bucket[N]` / `truncate[W]` (positive integer). */\n    readonly param?: number;\n}\n\nconst BUCKET_RE = /^bucket\\[\\s*(\\d+)\\s*\\]$/;\nconst TRUNCATE_RE = /^truncate\\[\\s*(\\d+)\\s*\\]$/;\n\n/**\n * Parse an Iceberg transform string. Matching is case-insensitive.\n *\n * @param transformStr Transform string from a partition definition.\n * @returns The parsed transform, or null if it is not a valid transform.\n */\nexport function parseIcebergTransform(transformStr: string): IcebergTransform | null {\n    const trimmed = transformStr.trim().toLowerCase();\n\n    if ((NULLARY_TRANSFORMS as string[]).includes(trimmed)) {\n        return {\n            kind: trimmed as IcebergTransformKind,\n        };\n    }\n\n    const bucketMatch = BUCKET_RE.exec(trimmed);\n    if (bucketMatch) {\n        const param = Number(bucketMatch[1]);\n        if (param < 1) {\n            return null;\n        }\n        return {\n            kind: IcebergTransformKind.BUCKET,\n            param,\n        };\n    }\n\n    const truncateMatch = TRUNCATE_RE.exec(trimmed);\n    if (truncateMatch) {\n        const param = Number(truncateMatch[1]);\n        if (param < 1) {\n            return null;\n        }\n        return {\n            kind: IcebergTransformKind.TRUNCATE,\n            param,\n        };\n    }\n\n    return null;\n}\n\nfunction isTemporal(kind: IcebergTypeKind): boolean {\n    return kind === IcebergTypeKind.DATE\n        || kind === IcebergTypeKind.TIMESTAMP\n        || kind === IcebergTypeKind.TIMESTAMPTZ;\n}\n\nfunction isTimestamp(kind: IcebergTypeKind): boolean {\n    return kind === IcebergTypeKind.TIMESTAMP\n        || kind === IcebergTypeKind.TIMESTAMPTZ;\n}\n\nconst BUCKET_LEGAL: ReadonlySet<IcebergTypeKind> = new Set([\n    IcebergTypeKind.INT,\n    IcebergTypeKind.LONG,\n    IcebergTypeKind.DATE,\n    IcebergTypeKind.TIME,\n    IcebergTypeKind.TIMESTAMP,\n    IcebergTypeKind.TIMESTAMPTZ,\n    IcebergTypeKind.STRING,\n    IcebergTypeKind.UUID,\n    IcebergTypeKind.BINARY,\n    IcebergTypeKind.DECIMAL,\n    IcebergTypeKind.FIXED,\n]);\n\nconst TRUNCATE_LEGAL: ReadonlySet<IcebergTypeKind> = new Set([\n    IcebergTypeKind.INT,\n    IcebergTypeKind.LONG,\n    IcebergTypeKind.STRING,\n    IcebergTypeKind.BINARY,\n    IcebergTypeKind.DECIMAL,\n]);\n\nfunction isBucketLegal(kind: IcebergTypeKind): boolean {\n    return BUCKET_LEGAL.has(kind);\n}\n\nfunction isTruncateLegal(kind: IcebergTypeKind): boolean {\n    return TRUNCATE_LEGAL.has(kind);\n}\n\n/**\n * Whether a transform is legal on a given source-column type. Mirrors arceus's\n * `IcebergPartitionTransform.validateSourceType`.\n *\n * @param transform Parsed transform.\n * @param sourceType Parsed source-column type.\n * @returns True when the transform may be applied to that type.\n */\nexport function transformLegalOnType(transform: IcebergTransform, sourceType: IcebergType): boolean {\n    switch (transform.kind) {\n        case IcebergTransformKind.IDENTITY:\n        case IcebergTransformKind.VOID:\n            return true;\n        case IcebergTransformKind.YEAR:\n        case IcebergTransformKind.MONTH:\n        case IcebergTransformKind.DAY:\n            return isTemporal(sourceType.kind);\n        case IcebergTransformKind.HOUR:\n            return isTimestamp(sourceType.kind);\n        case IcebergTransformKind.BUCKET:\n            return isBucketLegal(sourceType.kind);\n        case IcebergTransformKind.TRUNCATE:\n            return isTruncateLegal(sourceType.kind);\n        /* istanbul ignore next: exhaustive — every kind is handled above */\n        default:\n            return false;\n    }\n}\n"]}

package/dist/src/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Public API for the FDD core package.
+ */
+export * from './model';
+export { LoadedSchema, World, runSemanticRules, } from './world';
+export { validateRoot, } from './validate';
+export { loadRoot, LoadOutcome, } from './loader';
+export { TableTypeBase, TableTypeFields, } from './table-type';
+export { createTableType, } from './table-types/registry';
+export { HiveParquetTable, } from './table-types/hive-parquet';
+export { IcebergParquetTable, } from './table-types/iceberg-parquet';
+export { Postgres18Table, } from './table-types/postgres-18';
+export { validateStructure, StructuralKind, StructuralResult, StructuralError, } from './structural';
+export { isValidHiveType, isValidPostgresType, } from './types';
+export { parseIcebergType, isValidIcebergType, parseIcebergTransform, transformLegalOnType, IcebergType, IcebergTypeKind, IcebergTransform, IcebergTransformKind, } from './iceberg';
+export { buildDagDot, } from './diagram/dag';
+export { buildErDot, } from './diagram/er';
+export { renderDot, } from './diagram/render';

package/dist/src/index.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * Public API for the FDD core package.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderDot = exports.buildErDot = exports.buildDagDot = exports.IcebergTransformKind = exports.IcebergTypeKind = exports.transformLegalOnType = exports.parseIcebergTransform = exports.isValidIcebergType = exports.parseIcebergType = exports.isValidPostgresType = exports.isValidHiveType = exports.validateStructure = exports.Postgres18Table = exports.IcebergParquetTable = exports.HiveParquetTable = exports.createTableType = exports.TableTypeBase = exports.loadRoot = exports.validateRoot = exports.runSemanticRules = void 0;
+__exportStar(require("./model"), exports);
+var world_1 = require("./world");
+Object.defineProperty(exports, "runSemanticRules", { enumerable: true, get: function () { return world_1.runSemanticRules; } });
+var validate_1 = require("./validate");
+Object.defineProperty(exports, "validateRoot", { enumerable: true, get: function () { return validate_1.validateRoot; } });
+var loader_1 = require("./loader");
+Object.defineProperty(exports, "loadRoot", { enumerable: true, get: function () { return loader_1.loadRoot; } });
+var table_type_1 = require("./table-type");
+Object.defineProperty(exports, "TableTypeBase", { enumerable: true, get: function () { return table_type_1.TableTypeBase; } });
+var registry_1 = require("./table-types/registry");
+Object.defineProperty(exports, "createTableType", { enumerable: true, get: function () { return registry_1.createTableType; } });
+var hive_parquet_1 = require("./table-types/hive-parquet");
+Object.defineProperty(exports, "HiveParquetTable", { enumerable: true, get: function () { return hive_parquet_1.HiveParquetTable; } });
+var iceberg_parquet_1 = require("./table-types/iceberg-parquet");
+Object.defineProperty(exports, "IcebergParquetTable", { enumerable: true, get: function () { return iceberg_parquet_1.IcebergParquetTable; } });
+var postgres_18_1 = require("./table-types/postgres-18");
+Object.defineProperty(exports, "Postgres18Table", { enumerable: true, get: function () { return postgres_18_1.Postgres18Table; } });
+var structural_1 = require("./structural");
+Object.defineProperty(exports, "validateStructure", { enumerable: true, get: function () { return structural_1.validateStructure; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "isValidHiveType", { enumerable: true, get: function () { return types_1.isValidHiveType; } });
+Object.defineProperty(exports, "isValidPostgresType", { enumerable: true, get: function () { return types_1.isValidPostgresType; } });
+var iceberg_1 = require("./iceberg");
+Object.defineProperty(exports, "parseIcebergType", { enumerable: true, get: function () { return iceberg_1.parseIcebergType; } });
+Object.defineProperty(exports, "isValidIcebergType", { enumerable: true, get: function () { return iceberg_1.isValidIcebergType; } });
+Object.defineProperty(exports, "parseIcebergTransform", { enumerable: true, get: function () { return iceberg_1.parseIcebergTransform; } });
+Object.defineProperty(exports, "transformLegalOnType", { enumerable: true, get: function () { return iceberg_1.transformLegalOnType; } });
+Object.defineProperty(exports, "IcebergTypeKind", { enumerable: true, get: function () { return iceberg_1.IcebergTypeKind; } });
+Object.defineProperty(exports, "IcebergTransformKind", { enumerable: true, get: function () { return iceberg_1.IcebergTransformKind; } });
+var dag_1 = require("./diagram/dag");
+Object.defineProperty(exports, "buildDagDot", { enumerable: true, get: function () { return dag_1.buildDagDot; } });
+var er_1 = require("./diagram/er");
+Object.defineProperty(exports, "buildErDot", { enumerable: true, get: function () { return er_1.buildErDot; } });
+var render_1 = require("./diagram/render");
+Object.defineProperty(exports, "renderDot", { enumerable: true, get: function () { return render_1.renderDot; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOztHQUVHOzs7Ozs7Ozs7Ozs7Ozs7OztBQUVILDBDQUF3QjtBQUN4QixpQ0FJaUI7QUFEYix5R0FBQSxnQkFBZ0IsT0FBQTtBQUVwQix1Q0FFb0I7QUFEaEIsd0dBQUEsWUFBWSxPQUFBO0FBRWhCLG1DQUdrQjtBQUZkLGtHQUFBLFFBQVEsT0FBQTtBQUdaLDJDQUdzQjtBQUZsQiwyR0FBQSxhQUFhLE9BQUE7QUFHakIsbURBRWdDO0FBRDVCLDJHQUFBLGVBQWUsT0FBQTtBQUVuQiwyREFFb0M7QUFEaEMsZ0hBQUEsZ0JBQWdCLE9BQUE7QUFFcEIsaUVBRXVDO0FBRG5DLHNIQUFBLG1CQUFtQixPQUFBO0FBRXZCLHlEQUVtQztBQUQvQiw4R0FBQSxlQUFlLE9BQUE7QUFFbkIsMkNBS3NCO0FBSmxCLCtHQUFBLGlCQUFpQixPQUFBO0FBS3JCLGlDQUdpQjtBQUZiLHdHQUFBLGVBQWUsT0FBQTtBQUNmLDRHQUFBLG1CQUFtQixPQUFBO0FBRXZCLHFDQVNtQjtBQVJmLDJHQUFBLGdCQUFnQixPQUFBO0FBQ2hCLDZHQUFBLGtCQUFrQixPQUFBO0FBQ2xCLGdIQUFBLHFCQUFxQixPQUFBO0FBQ3JCLCtHQUFBLG9CQUFvQixPQUFBO0FBRXBCLDBHQUFBLGVBQWUsT0FBQTtBQUVmLCtHQUFBLG9CQUFvQixPQUFBO0FBRXhCLHFDQUV1QjtBQURuQixrR0FBQSxXQUFXLE9BQUE7QUFFZixtQ0FFc0I7QUFEbEIsZ0dBQUEsVUFBVSxPQUFBO0FBRWQsMkNBRTBCO0FBRHRCLG1HQUFBLFNBQVMsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUHVibGljIEFQSSBmb3IgdGhlIEZERCBjb3JlIHBhY2thZ2UuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9tb2RlbCc7XG5leHBvcnQge1xuICAgIExvYWRlZFNjaGVtYSxcbiAgICBXb3JsZCxcbiAgICBydW5TZW1hbnRpY1J1bGVzLFxufSBmcm9tICcuL3dvcmxkJztcbmV4cG9ydCB7XG4gICAgdmFsaWRhdGVSb290LFxufSBmcm9tICcuL3ZhbGlkYXRlJztcbmV4cG9ydCB7XG4gICAgbG9hZFJvb3QsXG4gICAgTG9hZE91dGNvbWUsXG59IGZyb20gJy4vbG9hZGVyJztcbmV4cG9ydCB7XG4gICAgVGFibGVUeXBlQmFzZSxcbiAgICBUYWJsZVR5cGVGaWVsZHMsXG59IGZyb20gJy4vdGFibGUtdHlwZSc7XG5leHBvcnQge1xuICAgIGNyZWF0ZVRhYmxlVHlwZSxcbn0gZnJvbSAnLi90YWJsZS10eXBlcy9yZWdpc3RyeSc7XG5leHBvcnQge1xuICAgIEhpdmVQYXJxdWV0VGFibGUsXG59IGZyb20gJy4vdGFibGUtdHlwZXMvaGl2ZS1wYXJxdWV0JztcbmV4cG9ydCB7XG4gICAgSWNlYmVyZ1BhcnF1ZXRUYWJsZSxcbn0gZnJvbSAnLi90YWJsZS10eXBlcy9pY2ViZXJnLXBhcnF1ZXQnO1xuZXhwb3J0IHtcbiAgICBQb3N0Z3JlczE4VGFibGUsXG59IGZyb20gJy4vdGFibGUtdHlwZXMvcG9zdGdyZXMtMTgnO1xuZXhwb3J0IHtcbiAgICB2YWxpZGF0ZVN0cnVjdHVyZSxcbiAgICBTdHJ1Y3R1cmFsS2luZCxcbiAgICBTdHJ1Y3R1cmFsUmVzdWx0LFxuICAgIFN0cnVjdHVyYWxFcnJvcixcbn0gZnJvbSAnLi9zdHJ1Y3R1cmFsJztcbmV4cG9ydCB7XG4gICAgaXNWYWxpZEhpdmVUeXBlLFxuICAgIGlzVmFsaWRQb3N0Z3Jlc1R5cGUsXG59IGZyb20gJy4vdHlwZXMnO1xuZXhwb3J0IHtcbiAgICBwYXJzZUljZWJlcmdUeXBlLFxuICAgIGlzVmFsaWRJY2ViZXJnVHlwZSxcbiAgICBwYXJzZUljZWJlcmdUcmFuc2Zvcm0sXG4gICAgdHJhbnNmb3JtTGVnYWxPblR5cGUsXG4gICAgSWNlYmVyZ1R5cGUsXG4gICAgSWNlYmVyZ1R5cGVLaW5kLFxuICAgIEljZWJlcmdUcmFuc2Zvcm0sXG4gICAgSWNlYmVyZ1RyYW5zZm9ybUtpbmQsXG59IGZyb20gJy4vaWNlYmVyZyc7XG5leHBvcnQge1xuICAgIGJ1aWxkRGFnRG90LFxufSBmcm9tICcuL2RpYWdyYW0vZGFnJztcbmV4cG9ydCB7XG4gICAgYnVpbGRFckRvdCxcbn0gZnJvbSAnLi9kaWFncmFtL2VyJztcbmV4cG9ydCB7XG4gICAgcmVuZGVyRG90LFxufSBmcm9tICcuL2RpYWdyYW0vcmVuZGVyJztcbiJdfQ==

package/dist/src/loader.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Filesystem loader. Walks a dataset root, parses each JSON file, runs Layer 1
+ * structural validation, and normalizes everything into a `World` of
+ * concrete `TableTypeBase` instances that the semantic rules operate on.
+ *
+ * Parse errors, structural errors, and a missing schema-description file are
+ * reported here; all cross-field / cross-file logic lives in the table-type
+ * classes (`./table-type.ts`, `./table-types/*`).
+ */
+import { Violation } from './model';
+import { World } from './world';
+/** Result of loading a root: the model plus any load-time violations. */
+export interface LoadOutcome {
+    /** The loaded model. */
+    readonly world: World;
+    /** Parse, structural, and missing-description violations. */
+    readonly violations: Violation[];
+}
+/**
+ * Load a dataset root into a `World`.
+ *
+ * @param rootDir Absolute or relative path to the dataset root.
+ * @returns The loaded world plus load-time violations.
+ * @throws Error When `rootDir` is not an existing directory.
+ */
+export declare function loadRoot(rootDir: string): LoadOutcome;