flexdataset 0.4.1

package/dist/src/structural.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * Layer 1 (structural) validation, backed by JSON Schema via ajv.
+ *
+ * The schema files in `./schema` are the portable artifact: any language can
+ * validate a file natively against them. This module is the TypeScript core's
+ * own use of those same schemas.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateStructure = validateStructure;
+const ajv_1 = __importDefault(require("ajv"));
+const ajv_formats_1 = __importDefault(require("ajv-formats"));
+const table_schema_json_1 = __importDefault(require("./schema/table.schema.json"));
+const schema_schema_json_1 = __importDefault(require("./schema/schema.schema.json"));
+const ajv = new ajv_1.default({
+    allErrors: true,
+    allowUnionTypes: true,
+});
+(0, ajv_formats_1.default)(ajv);
+const validators = {
+    table: ajv.compile(table_schema_json_1.default),
+    schema: ajv.compile(schema_schema_json_1.default),
+};
+/**
+ * Validate parsed JSON against a structural schema.
+ *
+ * @param kind Which schema to use.
+ * @param data Parsed JSON content.
+ * @returns Whether it is valid plus any structural errors.
+ */
+function validateStructure(kind, data) {
+    const validate = validators[kind];
+    const valid = validate(data);
+    if (valid) {
+        return {
+            valid: true,
+            errors: [],
+        };
+    }
+    /* istanbul ignore next: ajv always populates `errors` when validation fails */
+    const rawErrors = validate.errors ?? [];
+    const errors = rawErrors.map((error) => ({
+        field: error.instancePath,
+        message: `${error.instancePath || '(root)'} ${error.message}`.trim(),
+    }));
+    return {
+        valid: false,
+        errors,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/table-type.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Abstract base class for a loaded table. One subclass per engine.
+ *
+ * Holds the normalized table identity and definition, plus the
+ * engine-agnostic Layer 2 rules as concrete methods. Engine-specific rules
+ * (column-type validity, partition semantics) are abstract — each subclass
+ * implements them, which is the lever that lets new engines plug in without
+ * editing scattered switches. The cross-file rules are concrete here too;
+ * they take the world by an interface so the cycle between this module and
+ * `./world` is kept at type-level only.
+ */
+import { TableDefinition, Violation } from './model';
+import type { World } from './world';
+/** Fields required to construct any concrete table subclass. */
+export interface TableTypeFields {
+    /** Owning schema name (the folder name). */
+    readonly schema: string;
+    /** Table name (the file name without `.json`). */
+    readonly name: string;
+    /** `schema.table` identifier. */
+    readonly qualifiedName: string;
+    /** Absolute path to the source file. */
+    readonly filePath: string;
+    /** Whether the file passed Layer 1 structural validation. */
+    readonly structurallyValid: boolean;
+    /** Normalized definition. */
+    readonly definition: TableDefinition;
+}
+/**
+ * Base class for all engine-specific table types.
+ *
+ * Subclasses implement `isValidColumnType` (the engine's type registry) and
+ * `partitionViolations` (the engine's partition semantics). Everything else
+ * — primary-key checks, dupes, raw consistency, depends-on resolution,
+ * foreign-key checks — is identical across engines and lives here.
+ */
+export declare abstract class TableTypeBase {
+    /** Owning schema name. */
+    readonly schema: string;
+    /** Table name. */
+    readonly name: string;
+    /** `schema.table` identifier. */
+    readonly qualifiedName: string;
+    /** Absolute path to the source file. */
+    readonly filePath: string;
+    /** Whether the file passed Layer 1 structural validation. */
+    readonly structurallyValid: boolean;
+    /** Normalized definition. */
+    readonly definition: TableDefinition;
+    /**
+     * Construct a table instance from the normalized fields produced by the
+     * loader.
+     *
+     * @param fields The table identity plus its parsed, normalized definition.
+     */
+    constructor(fields: TableTypeFields);
+    /**
+     * Build a violation pre-filled with this table's location fields.
+     *
+     * @param partial The fields specific to the rule firing (code, level, message, field).
+     * @returns A full `Violation` with `schema`, `table`, and `path` set.
+     */
+    protected violation(partial: Omit<Violation, 'schema' | 'table' | 'path'>): Violation;
+    /**
+     * Whether this table declares a data column with the given name.
+     *
+     * @param name Column name to look up.
+     * @returns True when `name` matches any column in `definition.columns`.
+     */
+    protected hasColumn(name: string): boolean;
+    /**
+     * Find names that appear more than once in a list, preserving the order
+     * of first duplication.
+     *
+     * @param names Names to scan.
+     * @returns Duplicated names, each listed once.
+     */
+    protected findDuplicates(names: string[]): string[];
+    /**
+     * Whether `type` is a valid column-type string for this engine.
+     *
+     * @param type Column type string to check.
+     * @returns True when the engine accepts the type.
+     */
+    abstract isValidColumnType(type: string): boolean;
+    /**
+     * Engine-specific partition rules: duplicate detection, type/transform
+     * legality, and the "no partitions allowed" rule for engines that don't
+     * support them.
+     *
+     * @returns Every partition-related violation this table produces.
+     */
+    abstract partitionViolations(): Violation[];
+    private primaryKeyViolations;
+    private duplicateColumnViolations;
+    private columnTypeViolations;
+    private rawConsistencyViolations;
+    /**
+     * All intra-table violations for this table (engine-agnostic rules plus
+     * the engine-specific partition rules).
+     *
+     * @returns Every intra-table violation this table produces.
+     */
+    intraTableViolations(): Violation[];
+    private dependsOnViolations;
+    private foreignKeyViolations;
+    /**
+     * All cross-file violations for this table (`dependsOn` resolution plus
+     * the full foreign-key suite).
+     *
+     * @param world The loaded dataset root.
+     * @returns Every cross-file violation this table produces.
+     */
+    crossFileViolations(world: World): Violation[];
+}

package/dist/src/table-type.js

@@ -0,0 +1,275 @@
+"use strict";
+/**
+ * Abstract base class for a loaded table. One subclass per engine.
+ *
+ * Holds the normalized table identity and definition, plus the
+ * engine-agnostic Layer 2 rules as concrete methods. Engine-specific rules
+ * (column-type validity, partition semantics) are abstract — each subclass
+ * implements them, which is the lever that lets new engines plug in without
+ * editing scattered switches. The cross-file rules are concrete here too;
+ * they take the world by an interface so the cycle between this module and
+ * `./world` is kept at type-level only.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableTypeBase = void 0;
+/**
+ * Base class for all engine-specific table types.
+ *
+ * Subclasses implement `isValidColumnType` (the engine's type registry) and
+ * `partitionViolations` (the engine's partition semantics). Everything else
+ * — primary-key checks, dupes, raw consistency, depends-on resolution,
+ * foreign-key checks — is identical across engines and lives here.
+ */
+class TableTypeBase {
+    /** Owning schema name. */
+    schema;
+    /** Table name. */
+    name;
+    /** `schema.table` identifier. */
+    qualifiedName;
+    /** Absolute path to the source file. */
+    filePath;
+    /** Whether the file passed Layer 1 structural validation. */
+    structurallyValid;
+    /** Normalized definition. */
+    definition;
+    /**
+     * Construct a table instance from the normalized fields produced by the
+     * loader.
+     *
+     * @param fields The table identity plus its parsed, normalized definition.
+     */
+    constructor(fields) {
+        this.schema = fields.schema;
+        this.name = fields.name;
+        this.qualifiedName = fields.qualifiedName;
+        this.filePath = fields.filePath;
+        this.structurallyValid = fields.structurallyValid;
+        this.definition = fields.definition;
+    }
+    /// ////////////////////////////////////////////////////////////////////////
+    // Helpers shared by intra-table and cross-file rules.
+    /**
+     * Build a violation pre-filled with this table's location fields.
+     *
+     * @param partial The fields specific to the rule firing (code, level, message, field).
+     * @returns A full `Violation` with `schema`, `table`, and `path` set.
+     */
+    violation(partial) {
+        const location = {
+            schema: this.schema,
+            table: this.name,
+            path: this.filePath,
+        };
+        return {
+            ...partial,
+            ...location,
+        };
+    }
+    /**
+     * Whether this table declares a data column with the given name.
+     *
+     * @param name Column name to look up.
+     * @returns True when `name` matches any column in `definition.columns`.
+     */
+    hasColumn(name) {
+        return this.definition.columns.some((column) => column.name === name);
+    }
+    /**
+     * Find names that appear more than once in a list, preserving the order
+     * of first duplication.
+     *
+     * @param names Names to scan.
+     * @returns Duplicated names, each listed once.
+     */
+    findDuplicates(names) {
+        const seen = new Set();
+        const duplicates = new Set();
+        for (const name of names) {
+            if (seen.has(name)) {
+                duplicates.add(name);
+            }
+            seen.add(name);
+        }
+        return [
+            ...duplicates,
+        ];
+    }
+    /// ////////////////////////////////////////////////////////////////////////
+    // Agnostic intra-table rules.
+    /// PK_COLUMNS_EXIST — every primary-key column exists in `columns`.
+    primaryKeyViolations() {
+        const violations = [];
+        for (const pkColumn of this.definition.primaryKey) {
+            if (!this.hasColumn(pkColumn)) {
+                violations.push(this.violation({
+                    level: 'error',
+                    code: 'PK_COLUMNS_EXIST',
+                    field: 'primaryKey',
+                    message: `primary-key column "${pkColumn}" is not defined in columns`,
+                }));
+            }
+        }
+        return violations;
+    }
+    /// NO_DUPLICATE_COLUMNS — column names are unique within a table.
+    duplicateColumnViolations() {
+        const names = this.definition.columns.map((column) => column.name);
+        return this.findDuplicates(names).map((duplicate) => this.violation({
+            level: 'error',
+            code: 'NO_DUPLICATE_COLUMNS',
+            field: 'columns',
+            message: `duplicate column name "${duplicate}"`,
+        }));
+    }
+    /// COLUMN_TYPE_VALID — every column type is valid for the table's engine.
+    columnTypeViolations() {
+        const violations = [];
+        this.definition.columns.forEach((column, index) => {
+            if (!this.isValidColumnType(column.type)) {
+                violations.push(this.violation({
+                    level: 'error',
+                    code: 'COLUMN_TYPE_VALID',
+                    field: `columns[${index}].type`,
+                    message: `"${column.type}" is not a valid ${this.definition.tableType} type `
+                        + `for column "${column.name}"`,
+                }));
+            }
+        });
+        return violations;
+    }
+    /// RAW_NO_DEPENDS_ON / NONRAW_REQUIRES_DEPENDS_ON.
+    rawConsistencyViolations() {
+        const violations = [];
+        const { isRawData, dependsOn, } = this.definition;
+        if (isRawData && dependsOn.length > 0) {
+            violations.push(this.violation({
+                level: 'error',
+                code: 'RAW_NO_DEPENDS_ON',
+                field: 'dependsOn',
+                message: 'raw tables (isRawData=true) must not declare dependsOn',
+            }));
+        }
+        if (!isRawData && dependsOn.length === 0) {
+            violations.push(this.violation({
+                level: 'error',
+                code: 'NONRAW_REQUIRES_DEPENDS_ON',
+                field: 'dependsOn',
+                message: 'non-raw tables (isRawData=false) must declare at least one dependsOn',
+            }));
+        }
+        return violations;
+    }
+    /**
+     * All intra-table violations for this table (engine-agnostic rules plus
+     * the engine-specific partition rules).
+     *
+     * @returns Every intra-table violation this table produces.
+     */
+    intraTableViolations() {
+        return [
+            ...this.primaryKeyViolations(),
+            ...this.duplicateColumnViolations(),
+            ...this.columnTypeViolations(),
+            ...this.partitionViolations(),
+            ...this.rawConsistencyViolations(),
+        ];
+    }
+    /// ////////////////////////////////////////////////////////////////////////
+    // Cross-file rules.
+    /// DEPENDS_ON_RESOLVES — every dependsOn entry resolves to a real table.
+    dependsOnViolations(world) {
+        const violations = [];
+        this.definition.dependsOn.forEach((dependency, index) => {
+            if (!world.tables.has(dependency)) {
+                violations.push(this.violation({
+                    level: 'error',
+                    code: 'DEPENDS_ON_RESOLVES',
+                    field: `dependsOn[${index}]`,
+                    message: `dependsOn "${dependency}" does not resolve to a known table`,
+                }));
+            }
+        });
+        return violations;
+    }
+    /// Foreign-key checks for a single FK entry.
+    foreignKeyViolations(world, fk, index) {
+        const violations = [];
+        const field = `foreignKeys[${index}]`;
+        if (!this.hasColumn(fk.localColumn)) {
+            violations.push(this.violation({
+                level: 'error',
+                code: 'FK_LOCAL_COLUMN_EXISTS',
+                field: `${field}.localColumn`,
+                message: `local column "${fk.localColumn}" is not defined in columns`,
+            }));
+        }
+        /// A self-referential foreign key (e.g. a `parent_id` pointing at the same
+        /// table's key) does not create a pipeline dependency, so it is exempt from
+        /// FK_IMPLIES_DEPENDENCY — requiring a self-`dependsOn` would otherwise force
+        /// a spurious dependency cycle.
+        const isSelfReference = fk.sourceTable === this.qualifiedName;
+        if (!isSelfReference && !this.definition.dependsOn.includes(fk.sourceTable)) {
+            violations.push(this.violation({
+                level: 'error',
+                code: 'FK_IMPLIES_DEPENDENCY',
+                field: `${field}.sourceTable`,
+                message: `foreign key targets "${fk.sourceTable}" but it is not listed in dependsOn`,
+            }));
+        }
+        const target = world.tables.get(fk.sourceTable);
+        if (target === undefined) {
+            violations.push(this.violation({
+                level: 'error',
+                code: 'FK_SOURCE_TABLE_RESOLVES',
+                field: `${field}.sourceTable`,
+                message: `foreign key source table "${fk.sourceTable}" does not resolve to a known table`,
+            }));
+            return violations;
+        }
+        /// The target's own structural errors (reported by Layer 1) already explain
+        /// why its columns can't be trusted; skip column-level checks to avoid
+        /// piling misleading findings on top.
+        if (!target.structurallyValid) {
+            return violations;
+        }
+        const targetHasColumn = target.definition.columns.some((column) => column.name === fk.sourceColumn);
+        if (!targetHasColumn) {
+            violations.push(this.violation({
+                level: 'error',
+                code: 'FK_SOURCE_COLUMN_EXISTS',
+                field: `${field}.sourceColumn`,
+                message: `foreign key source column "${fk.sourceColumn}" is not defined in "${fk.sourceTable}"`,
+            }));
+            return violations;
+        }
+        if (!target.definition.primaryKey.includes(fk.sourceColumn)) {
+            violations.push(this.violation({
+                level: 'warning',
+                code: 'FK_SOURCE_IS_KEY',
+                field: `${field}.sourceColumn`,
+                message: `foreign key source column "${fk.sourceColumn}" is not part of the primary key `
+                    + `of "${fk.sourceTable}"`,
+            }));
+        }
+        return violations;
+    }
+    /**
+     * All cross-file violations for this table (`dependsOn` resolution plus
+     * the full foreign-key suite).
+     *
+     * @param world The loaded dataset root.
+     * @returns Every cross-file violation this table produces.
+     */
+    crossFileViolations(world) {
+        const violations = [
+            ...this.dependsOnViolations(world),
+        ];
+        this.definition.foreignKeys.forEach((fk, index) => {
+            violations.push(...this.foreignKeyViolations(world, fk, index));
+        });
+        return violations;
+    }
+}
+exports.TableTypeBase = TableTypeBase;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-type.js","sourceRoot":"","sources":["../../src/table-type.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Abstract base class for a loaded table. One subclass per engine.\n *\n * Holds the normalized table identity and definition, plus the\n * engine-agnostic Layer 2 rules as concrete methods. Engine-specific rules\n * (column-type validity, partition semantics) are abstract — each subclass\n * implements them, which is the lever that lets new engines plug in without\n * editing scattered switches. The cross-file rules are concrete here too;\n * they take the world by an interface so the cycle between this module and\n * `./world` is kept at type-level only.\n */\n\nimport {\n    ForeignKey,\n    TableDefinition,\n    Violation,\n} from './model';\nimport type {\n    World,\n} from './world';\n\n/** Fields required to construct any concrete table subclass. */\nexport interface TableTypeFields {\n    /** Owning schema name (the folder name). */\n    readonly schema: string;\n\n    /** Table name (the file name without `.json`). */\n    readonly name: string;\n\n    /** `schema.table` identifier. */\n    readonly qualifiedName: string;\n\n    /** Absolute path to the source file. */\n    readonly filePath: string;\n\n    /** Whether the file passed Layer 1 structural validation. */\n    readonly structurallyValid: boolean;\n\n    /** Normalized definition. */\n    readonly definition: TableDefinition;\n}\n\n/** Pre-filled location fields attached to every violation a table emits. */\ntype LocationFields = Pick<Violation, 'schema' | 'table' | 'path'>;\n\n/**\n * Base class for all engine-specific table types.\n *\n * Subclasses implement `isValidColumnType` (the engine's type registry) and\n * `partitionViolations` (the engine's partition semantics). Everything else\n * — primary-key checks, dupes, raw consistency, depends-on resolution,\n * foreign-key checks — is identical across engines and lives here.\n */\nexport abstract class TableTypeBase {\n    /** Owning schema name. */\n    public readonly schema: string;\n\n    /** Table name. */\n    public readonly name: string;\n\n    /** `schema.table` identifier. */\n    public readonly qualifiedName: string;\n\n    /** Absolute path to the source file. */\n    public readonly filePath: string;\n\n    /** Whether the file passed Layer 1 structural validation. */\n    public readonly structurallyValid: boolean;\n\n    /** Normalized definition. */\n    public readonly definition: TableDefinition;\n\n    /**\n     * Construct a table instance from the normalized fields produced by the\n     * loader.\n     *\n     * @param fields The table identity plus its parsed, normalized definition.\n     */\n    constructor(fields: TableTypeFields) {\n        this.schema = fields.schema;\n        this.name = fields.name;\n        this.qualifiedName = fields.qualifiedName;\n        this.filePath = fields.filePath;\n        this.structurallyValid = fields.structurallyValid;\n        this.definition = fields.definition;\n    }\n\n    /// ////////////////////////////////////////////////////////////////////////\n    // Helpers shared by intra-table and cross-file rules.\n\n    /**\n     * Build a violation pre-filled with this table's location fields.\n     *\n     * @param partial The fields specific to the rule firing (code, level, message, field).\n     * @returns A full `Violation` with `schema`, `table`, and `path` set.\n     */\n    protected violation(partial: Omit<Violation, 'schema' | 'table' | 'path'>): Violation {\n        const location: LocationFields = {\n            schema: this.schema,\n            table: this.name,\n            path: this.filePath,\n        };\n        return {\n            ...partial,\n            ...location,\n        };\n    }\n\n    /**\n     * Whether this table declares a data column with the given name.\n     *\n     * @param name Column name to look up.\n     * @returns True when `name` matches any column in `definition.columns`.\n     */\n    protected hasColumn(name: string): boolean {\n        return this.definition.columns.some((column) => column.name === name);\n    }\n\n    /**\n     * Find names that appear more than once in a list, preserving the order\n     * of first duplication.\n     *\n     * @param names Names to scan.\n     * @returns Duplicated names, each listed once.\n     */\n    protected findDuplicates(names: string[]): string[] {\n        const seen = new Set<string>();\n        const duplicates = new Set<string>();\n        for (const name of names) {\n            if (seen.has(name)) {\n                duplicates.add(name);\n            }\n            seen.add(name);\n        }\n        return [\n            ...duplicates,\n        ];\n    }\n\n    /// ////////////////////////////////////////////////////////////////////////\n    // Engine-specific contract.\n\n    /**\n     * Whether `type` is a valid column-type string for this engine.\n     *\n     * @param type Column type string to check.\n     * @returns True when the engine accepts the type.\n     */\n    public abstract isValidColumnType(type: string): boolean;\n\n    /**\n     * Engine-specific partition rules: duplicate detection, type/transform\n     * legality, and the \"no partitions allowed\" rule for engines that don't\n     * support them.\n     *\n     * @returns Every partition-related violation this table produces.\n     */\n    public abstract partitionViolations(): Violation[];\n\n    /// ////////////////////////////////////////////////////////////////////////\n    // Agnostic intra-table rules.\n\n    /// PK_COLUMNS_EXIST — every primary-key column exists in `columns`.\n    private primaryKeyViolations(): Violation[] {\n        const violations: Violation[] = [];\n        for (const pkColumn of this.definition.primaryKey) {\n            if (!this.hasColumn(pkColumn)) {\n                violations.push(this.violation({\n                    level: 'error',\n                    code: 'PK_COLUMNS_EXIST',\n                    field: 'primaryKey',\n                    message: `primary-key column \"${pkColumn}\" is not defined in columns`,\n                }));\n            }\n        }\n        return violations;\n    }\n\n    /// NO_DUPLICATE_COLUMNS — column names are unique within a table.\n    private duplicateColumnViolations(): Violation[] {\n        const names = this.definition.columns.map((column) => column.name);\n        return this.findDuplicates(names).map((duplicate) => this.violation({\n            level: 'error',\n            code: 'NO_DUPLICATE_COLUMNS',\n            field: 'columns',\n            message: `duplicate column name \"${duplicate}\"`,\n        }));\n    }\n\n    /// COLUMN_TYPE_VALID — every column type is valid for the table's engine.\n    private columnTypeViolations(): Violation[] {\n        const violations: Violation[] = [];\n        this.definition.columns.forEach((column, index) => {\n            if (!this.isValidColumnType(column.type)) {\n                violations.push(this.violation({\n                    level: 'error',\n                    code: 'COLUMN_TYPE_VALID',\n                    field: `columns[${index}].type`,\n                    message: `\"${column.type}\" is not a valid ${this.definition.tableType} type `\n                        + `for column \"${column.name}\"`,\n                }));\n            }\n        });\n        return violations;\n    }\n\n    /// RAW_NO_DEPENDS_ON / NONRAW_REQUIRES_DEPENDS_ON.\n    private rawConsistencyViolations(): Violation[] {\n        const violations: Violation[] = [];\n        const {\n            isRawData,\n            dependsOn,\n        } = this.definition;\n        if (isRawData && dependsOn.length > 0) {\n            violations.push(this.violation({\n                level: 'error',\n                code: 'RAW_NO_DEPENDS_ON',\n                field: 'dependsOn',\n                message: 'raw tables (isRawData=true) must not declare dependsOn',\n            }));\n        }\n        if (!isRawData && dependsOn.length === 0) {\n            violations.push(this.violation({\n                level: 'error',\n                code: 'NONRAW_REQUIRES_DEPENDS_ON',\n                field: 'dependsOn',\n                message: 'non-raw tables (isRawData=false) must declare at least one dependsOn',\n            }));\n        }\n        return violations;\n    }\n\n    /**\n     * All intra-table violations for this table (engine-agnostic rules plus\n     * the engine-specific partition rules).\n     *\n     * @returns Every intra-table violation this table produces.\n     */\n    public intraTableViolations(): Violation[] {\n        return [\n            ...this.primaryKeyViolations(),\n            ...this.duplicateColumnViolations(),\n            ...this.columnTypeViolations(),\n            ...this.partitionViolations(),\n            ...this.rawConsistencyViolations(),\n        ];\n    }\n\n    /// ////////////////////////////////////////////////////////////////////////\n    // Cross-file rules.\n\n    /// DEPENDS_ON_RESOLVES — every dependsOn entry resolves to a real table.\n    private dependsOnViolations(world: World): Violation[] {\n        const violations: Violation[] = [];\n        this.definition.dependsOn.forEach((dependency, index) => {\n            if (!world.tables.has(dependency)) {\n                violations.push(this.violation({\n                    level: 'error',\n                    code: 'DEPENDS_ON_RESOLVES',\n                    field: `dependsOn[${index}]`,\n                    message: `dependsOn \"${dependency}\" does not resolve to a known table`,\n                }));\n            }\n        });\n        return violations;\n    }\n\n    /// Foreign-key checks for a single FK entry.\n    private foreignKeyViolations(world: World, fk: ForeignKey, index: number): Violation[] {\n        const violations: Violation[] = [];\n        const field = `foreignKeys[${index}]`;\n\n        if (!this.hasColumn(fk.localColumn)) {\n            violations.push(this.violation({\n                level: 'error',\n                code: 'FK_LOCAL_COLUMN_EXISTS',\n                field: `${field}.localColumn`,\n                message: `local column \"${fk.localColumn}\" is not defined in columns`,\n            }));\n        }\n\n        /// A self-referential foreign key (e.g. a `parent_id` pointing at the same\n        /// table's key) does not create a pipeline dependency, so it is exempt from\n        /// FK_IMPLIES_DEPENDENCY — requiring a self-`dependsOn` would otherwise force\n        /// a spurious dependency cycle.\n        const isSelfReference = fk.sourceTable === this.qualifiedName;\n        if (!isSelfReference && !this.definition.dependsOn.includes(fk.sourceTable)) {\n            violations.push(this.violation({\n                level: 'error',\n                code: 'FK_IMPLIES_DEPENDENCY',\n                field: `${field}.sourceTable`,\n                message: `foreign key targets \"${fk.sourceTable}\" but it is not listed in dependsOn`,\n            }));\n        }\n\n        const target = world.tables.get(fk.sourceTable);\n        if (target === undefined) {\n            violations.push(this.violation({\n                level: 'error',\n                code: 'FK_SOURCE_TABLE_RESOLVES',\n                field: `${field}.sourceTable`,\n                message: `foreign key source table \"${fk.sourceTable}\" does not resolve to a known table`,\n            }));\n            return violations;\n        }\n\n        /// The target's own structural errors (reported by Layer 1) already explain\n        /// why its columns can't be trusted; skip column-level checks to avoid\n        /// piling misleading findings on top.\n        if (!target.structurallyValid) {\n            return violations;\n        }\n\n        const targetHasColumn = target.definition.columns.some((column) => column.name === fk.sourceColumn);\n        if (!targetHasColumn) {\n            violations.push(this.violation({\n                level: 'error',\n                code: 'FK_SOURCE_COLUMN_EXISTS',\n                field: `${field}.sourceColumn`,\n                message: `foreign key source column \"${fk.sourceColumn}\" is not defined in \"${fk.sourceTable}\"`,\n            }));\n            return violations;\n        }\n\n        if (!target.definition.primaryKey.includes(fk.sourceColumn)) {\n            violations.push(this.violation({\n                level: 'warning',\n                code: 'FK_SOURCE_IS_KEY',\n                field: `${field}.sourceColumn`,\n                message: `foreign key source column \"${fk.sourceColumn}\" is not part of the primary key `\n                    + `of \"${fk.sourceTable}\"`,\n            }));\n        }\n\n        return violations;\n    }\n\n    /**\n     * All cross-file violations for this table (`dependsOn` resolution plus\n     * the full foreign-key suite).\n     *\n     * @param world The loaded dataset root.\n     * @returns Every cross-file violation this table produces.\n     */\n    public crossFileViolations(world: World): Violation[] {\n        const violations: Violation[] = [\n            ...this.dependsOnViolations(world),\n        ];\n        this.definition.foreignKeys.forEach((fk, index) => {\n            violations.push(...this.foreignKeyViolations(world, fk, index));\n        });\n        return violations;\n    }\n}\n"]}

package/dist/src/table-types/hive-parquet.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Hive (parquet) table type.
+ *
+ * Hive partitions are *new* columns at write time, distinct from data
+ * columns: their identity is the partition name and the validator forbids
+ * shadowing an existing data column.
+ */
+import { Violation } from '../model';
+import { TableTypeBase } from '../table-type';
+/** Hive (parquet) table. */
+export declare class HiveParquetTable extends TableTypeBase {
+    /**
+     * Validate a column type against the Hive type registry.
+     *
+     * @param type Type string from a column definition.
+     * @returns True when the type is a valid Hive type.
+     */
+    isValidColumnType(type: string): boolean;
+    /**
+     * Hive partition rules.
+     *
+     * Emits: `NO_DUPLICATE_PARTITIONS` (by partition name),
+     * `HIVE_PARTITION_NOT_IN_COLUMNS` (a Hive partition is a new column, so
+     * it must not collide with a data column), and `HIVE_PARTITION_TYPE_VALID`.
+     *
+     * @returns Every partition-related violation.
+     */
+    partitionViolations(): Violation[];
+}

package/dist/src/table-types/hive-parquet.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Hive (parquet) table type.
+ *
+ * Hive partitions are *new* columns at write time, distinct from data
+ * columns: their identity is the partition name and the validator forbids
+ * shadowing an existing data column.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HiveParquetTable = void 0;
+const table_type_1 = require("../table-type");
+const types_1 = require("../types");
+/** Hive (parquet) table. */
+class HiveParquetTable extends table_type_1.TableTypeBase {
+    /**
+     * Validate a column type against the Hive type registry.
+     *
+     * @param type Type string from a column definition.
+     * @returns True when the type is a valid Hive type.
+     */
+    isValidColumnType(type) {
+        return (0, types_1.isValidHiveType)(type);
+    }
+    /**
+     * Hive partition rules.
+     *
+     * Emits: `NO_DUPLICATE_PARTITIONS` (by partition name),
+     * `HIVE_PARTITION_NOT_IN_COLUMNS` (a Hive partition is a new column, so
+     * it must not collide with a data column), and `HIVE_PARTITION_TYPE_VALID`.
+     *
+     * @returns Every partition-related violation.
+     */
+    partitionViolations() {
+        const violations = [];
+        const { partitions, } = this.definition;
+        const seen = new Set();
+        partitions.forEach((partition, index) => {
+            if (seen.has(partition.name)) {
+                violations.push(this.violation({
+                    level: 'error',
+                    code: 'NO_DUPLICATE_PARTITIONS',
+                    field: `partitions[${index}]`,
+                    message: `duplicate partition name "${partition.name}"`,
+                }));
+            }
+            seen.add(partition.name);
+        });
+        partitions.forEach((partition, index) => {
+            if (this.hasColumn(partition.name)) {
+                violations.push(this.violation({
+                    level: 'error',
+                    code: 'HIVE_PARTITION_NOT_IN_COLUMNS',
+                    field: `partitions[${index}].name`,
+                    message: `Hive partition "${partition.name}" must not also be a data column`,
+                }));
+            }
+            if (!(0, types_1.isValidHiveType)(partition.type)) {
+                violations.push(this.violation({
+                    level: 'error',
+                    code: 'HIVE_PARTITION_TYPE_VALID',
+                    field: `partitions[${index}].type`,
+                    message: `"${partition.type}" is not a valid Hive partition type`,
+                }));
+            }
+        });
+        return violations;
+    }
+}
+exports.HiveParquetTable = HiveParquetTable;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/table-types/iceberg-parquet.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Iceberg (parquet) 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.
+ */
+import { Violation } from '../model';
+import { TableTypeBase } from '../table-type';
+/** Iceberg (parquet) table. */
+export declare class IcebergParquetTable extends TableTypeBase {
+    /**
+     * 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: string): boolean;
+    /**
+     * 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(): Violation[];
+    /**
+     * 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.
+     */
+    private partitionKey;
+}