flexdataset 0.4.1

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

@@ -0,0 +1,103 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IcebergParquetTable = void 0;
+const table_type_1 = require("../table-type");
+const iceberg_1 = require("../iceberg");
+/** Iceberg (parquet) table. */
+class IcebergParquetTable extends table_type_1.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) {
+        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;
+    }
+    /**
+     * 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.IcebergParquetTable = IcebergParquetTable;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"iceberg-parquet.js","sourceRoot":"","sources":["../../../src/table-types/iceberg-parquet.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Iceberg (parquet) 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\nimport {\n    Partition,\n    Violation,\n} from '../model';\nimport {\n    TableTypeBase,\n} from '../table-type';\nimport {\n    isValidIcebergType,\n    parseIcebergTransform,\n    parseIcebergType,\n    transformLegalOnType,\n} from '../iceberg';\n\n/** Iceberg (parquet) table. */\nexport class IcebergParquetTable extends TableTypeBase {\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    /**\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/postgres-18.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Postgres 18 table type.
+ *
+ * Postgres partitioning is deferred to a later FDD version, so any partition
+ * entry is an error.
+ */
+import { Violation } from '../model';
+import { TableTypeBase } from '../table-type';
+/** Postgres 18 table. */
+export declare class Postgres18Table extends TableTypeBase {
+    /**
+     * Validate a column type against the Postgres type registry.
+     *
+     * @param type Type string from a column definition.
+     * @returns True when the type is a valid Postgres 18 type.
+     */
+    isValidColumnType(type: string): boolean;
+    /**
+     * Postgres has no partitions in v0; emit `PARTITIONS_ALLOWED_FOR_TYPE`
+     * once when any partition entry is present.
+     *
+     * @returns The single partition violation when partitions are declared, otherwise empty.
+     */
+    partitionViolations(): Violation[];
+}

package/dist/src/table-types/postgres-18.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Postgres 18 table type.
+ *
+ * Postgres partitioning is deferred to a later FDD version, so any partition
+ * entry is an error.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Postgres18Table = void 0;
+const table_type_1 = require("../table-type");
+const types_1 = require("../types");
+/** Postgres 18 table. */
+class Postgres18Table extends table_type_1.TableTypeBase {
+    /**
+     * Validate a column type against the Postgres type registry.
+     *
+     * @param type Type string from a column definition.
+     * @returns True when the type is a valid Postgres 18 type.
+     */
+    isValidColumnType(type) {
+        return (0, types_1.isValidPostgresType)(type);
+    }
+    /**
+     * Postgres has no partitions in v0; emit `PARTITIONS_ALLOWED_FOR_TYPE`
+     * once when any partition entry is present.
+     *
+     * @returns The single partition violation when partitions are declared, otherwise empty.
+     */
+    partitionViolations() {
+        if (this.definition.partitions.length === 0) {
+            return [];
+        }
+        return [
+            this.violation({
+                level: 'error',
+                code: 'PARTITIONS_ALLOWED_FOR_TYPE',
+                field: 'partitions',
+                message: 'partitions are not supported for postgres_18 in v0',
+            }),
+        ];
+    }
+}
+exports.Postgres18Table = Postgres18Table;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/table-types/registry.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Registry mapping the `tableType` string to the concrete `TableTypeBase`
+ * subclass that implements it. Adding a new engine is a matter of writing a
+ * subclass and adding one entry here.
+ */
+import { TableTypeBase, TableTypeFields } from '../table-type';
+/**
+ * Build the concrete `TableTypeBase` subclass for the given fields.
+ *
+ * @param fields The normalized table fields.
+ * @returns A concrete table instance for the engine named by `fields.definition.tableType`.
+ */
+export declare function createTableType(fields: TableTypeFields): TableTypeBase;

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

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Registry mapping the `tableType` string to the concrete `TableTypeBase`
+ * subclass that implements it. Adding a new engine is a matter of writing a
+ * subclass and adding one entry here.
+ */
+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 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.POSTGRES_18]: postgres_18_1.Postgres18Table,
+};
+/**
+ * Build the concrete `TableTypeBase` subclass for the given fields.
+ *
+ * @param fields The normalized table fields.
+ * @returns A concrete table instance for the engine named by `fields.definition.tableType`.
+ */
+function createTableType(fields) {
+    const tableType = fields.definition.tableType;
+    /// An unrecognized `tableType` only occurs when Layer 1 already flagged the
+    /// file: such tables are skipped by intra-table rules and skipped as FK
+    /// targets, so the choice here is purely for cross-file *resolution* (the
+    /// instance still needs to land in `world.tables` so dependsOn / FK source
+    /// lookups don't pretend the file is missing). `HiveParquetTable` is the
+    /// resolution-only fallback.
+    const Constructor = REGISTRY[tableType] ?? hive_parquet_1.HiveParquetTable;
+    return new Constructor(fields);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/types.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Per-engine column-type registries for Hive and Postgres.
+ *
+ * Each function answers "is this type string valid for this engine?". The
+ * concrete `TableTypeBase` subclasses delegate `isValidColumnType` here (and
+ * the Iceberg subclass delegates to `./iceberg`).
+ */
+/** Whether the string is a valid Hive (parquet) column type. */
+export declare function isValidHiveType(typeStr: string): boolean;
+/** Whether the string is a valid Postgres 18 column type. */
+export declare function isValidPostgresType(typeStr: string): boolean;

package/dist/src/types.js

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * Per-engine column-type registries for Hive and Postgres.
+ *
+ * Each function answers "is this type string valid for this engine?". The
+ * concrete `TableTypeBase` subclasses delegate `isValidColumnType` here (and
+ * the Iceberg subclass delegates to `./iceberg`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidHiveType = isValidHiveType;
+exports.isValidPostgresType = isValidPostgresType;
+/// ////////////////////////////////////////////////////////////////////////////
+// Hive
+const HIVE_PRIMITIVES = new Set([
+    'tinyint',
+    'smallint',
+    'int',
+    'integer',
+    'bigint',
+    'boolean',
+    'float',
+    'double',
+    'double precision',
+    'string',
+    'binary',
+    'timestamp',
+    'date',
+    'interval',
+]);
+/**
+ * Split a generic-type body on top-level commas (ignoring commas nested inside
+ * `<...>`).
+ *
+ * @param body Inner text of a generic type.
+ * @returns The top-level comma-separated parts.
+ */
+function splitTopLevel(body) {
+    const parts = [];
+    let depth = 0;
+    let current = '';
+    for (const char of body) {
+        if (char === '<') {
+            depth += 1;
+        }
+        else if (char === '>') {
+            depth -= 1;
+        }
+        if (char === ',' && depth === 0) {
+            parts.push(current);
+            current = '';
+        }
+        else {
+            current += char;
+        }
+    }
+    parts.push(current);
+    return parts.map((part) => part.trim());
+}
+function isValidHiveStructField(field) {
+    const colon = field.indexOf(':');
+    if (colon <= 0) {
+        return false;
+    }
+    const name = field.slice(0, colon).trim();
+    const type = field.slice(colon + 1).trim();
+    return name.length > 0 && isValidHiveType(type);
+}
+/** Whether the string is a valid Hive (parquet) column type. */
+function isValidHiveType(typeStr) {
+    const type = typeStr.trim().toLowerCase();
+    if (HIVE_PRIMITIVES.has(type)) {
+        return true;
+    }
+    if (/^decimal\(\d+(,\s*\d+)?\)$/.test(type)) {
+        return true;
+    }
+    if (/^(varchar|char)\(\d+\)$/.test(type)) {
+        return true;
+    }
+    const open = type.indexOf('<');
+    if (open > 0 && type.endsWith('>')) {
+        const ctor = type.slice(0, open);
+        const inner = type.slice(open + 1, -1);
+        const parts = splitTopLevel(inner);
+        switch (ctor) {
+            case 'array':
+                return parts.length === 1 && isValidHiveType(parts[0]);
+            case 'map':
+                return parts.length === 2 && parts.every(isValidHiveType);
+            case 'uniontype':
+                return parts.length >= 1 && parts.every(isValidHiveType);
+            case 'struct':
+                return parts.length >= 1 && parts.every(isValidHiveStructField);
+            default:
+                return false;
+        }
+    }
+    return false;
+}
+/// ////////////////////////////////////////////////////////////////////////////
+// Postgres
+const POSTGRES_EXACT = new Set([
+    'smallint',
+    'integer',
+    'int',
+    'int2',
+    'int4',
+    'int8',
+    'bigint',
+    'real',
+    'float4',
+    'float8',
+    'double precision',
+    'money',
+    'text',
+    'bytea',
+    'boolean',
+    'bool',
+    'date',
+    'timestamp',
+    'timestamptz',
+    'timestamp with time zone',
+    'time',
+    'timetz',
+    'time with time zone',
+    'interval',
+    'uuid',
+    'json',
+    'jsonb',
+    'xml',
+    'inet',
+    'cidr',
+    'macaddr',
+    'macaddr8',
+    'smallserial',
+    'serial',
+    'bigserial',
+    'serial2',
+    'serial4',
+    'serial8',
+    'varchar',
+    'char',
+    'character',
+    'character varying',
+    'bpchar',
+    'numeric',
+    'decimal',
+    'bit',
+    'varbit',
+    'bit varying',
+]);
+const POSTGRES_PARAM_ALLOWED = new Set([
+    'varchar',
+    'char',
+    'character',
+    'character varying',
+    'bpchar',
+    'numeric',
+    'decimal',
+    'bit',
+    'varbit',
+    'bit varying',
+    'time',
+    'timetz',
+    'timestamp',
+    'timestamptz',
+    'interval',
+]);
+/** Whether the string is a valid Postgres 18 column type. */
+function isValidPostgresType(typeStr) {
+    let type = typeStr.trim().toLowerCase().replace(/\s+/g, ' ');
+    /// Strip one or more trailing array markers (`[]`, `[3]`).
+    type = type.replace(/(\s*\[\s*\d*\s*\])+$/, '').trim();
+    const paramMatch = /^(.*?)\(([^)]*)\)$/.exec(type);
+    if (paramMatch) {
+        const base = paramMatch[1].trim();
+        const params = paramMatch[2].trim();
+        return POSTGRES_PARAM_ALLOWED.has(base) && /^\d+(\s*,\s*\d+)?$/.test(params);
+    }
+    return POSTGRES_EXACT.has(type);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Per-engine column-type registries for Hive and Postgres.\n *\n * Each function answers \"is this type string valid for this engine?\". The\n * concrete `TableTypeBase` subclasses delegate `isValidColumnType` here (and\n * the Iceberg subclass delegates to `./iceberg`).\n */\n\n/// ////////////////////////////////////////////////////////////////////////////\n// Hive\n\nconst HIVE_PRIMITIVES: ReadonlySet<string> = new Set([\n    'tinyint',\n    'smallint',\n    'int',\n    'integer',\n    'bigint',\n    'boolean',\n    'float',\n    'double',\n    'double precision',\n    'string',\n    'binary',\n    'timestamp',\n    'date',\n    'interval',\n]);\n\n/**\n * Split a generic-type body on top-level commas (ignoring commas nested inside\n * `<...>`).\n *\n * @param body Inner text of a generic type.\n * @returns The top-level comma-separated parts.\n */\nfunction splitTopLevel(body: string): string[] {\n    const parts: string[] = [];\n    let depth = 0;\n    let current = '';\n    for (const char of body) {\n        if (char === '<') {\n            depth += 1;\n        } else if (char === '>') {\n            depth -= 1;\n        }\n        if (char === ',' && depth === 0) {\n            parts.push(current);\n            current = '';\n        } else {\n            current += char;\n        }\n    }\n    parts.push(current);\n    return parts.map((part) => part.trim());\n}\n\nfunction isValidHiveStructField(field: string): boolean {\n    const colon = field.indexOf(':');\n    if (colon <= 0) {\n        return false;\n    }\n    const name = field.slice(0, colon).trim();\n    const type = field.slice(colon + 1).trim();\n    return name.length > 0 && isValidHiveType(type);\n}\n\n/** Whether the string is a valid Hive (parquet) column type. */\nexport function isValidHiveType(typeStr: string): boolean {\n    const type = typeStr.trim().toLowerCase();\n\n    if (HIVE_PRIMITIVES.has(type)) {\n        return true;\n    }\n\n    if (/^decimal\\(\\d+(,\\s*\\d+)?\\)$/.test(type)) {\n        return true;\n    }\n\n    if (/^(varchar|char)\\(\\d+\\)$/.test(type)) {\n        return true;\n    }\n\n    const open = type.indexOf('<');\n    if (open > 0 && type.endsWith('>')) {\n        const ctor = type.slice(0, open);\n        const inner = type.slice(open + 1, -1);\n        const parts = splitTopLevel(inner);\n        switch (ctor) {\n            case 'array':\n                return parts.length === 1 && isValidHiveType(parts[0]);\n            case 'map':\n                return parts.length === 2 && parts.every(isValidHiveType);\n            case 'uniontype':\n                return parts.length >= 1 && parts.every(isValidHiveType);\n            case 'struct':\n                return parts.length >= 1 && parts.every(isValidHiveStructField);\n            default:\n                return false;\n        }\n    }\n\n    return false;\n}\n\n/// ////////////////////////////////////////////////////////////////////////////\n// Postgres\n\nconst POSTGRES_EXACT: ReadonlySet<string> = new Set([\n    'smallint',\n    'integer',\n    'int',\n    'int2',\n    'int4',\n    'int8',\n    'bigint',\n    'real',\n    'float4',\n    'float8',\n    'double precision',\n    'money',\n    'text',\n    'bytea',\n    'boolean',\n    'bool',\n    'date',\n    'timestamp',\n    'timestamptz',\n    'timestamp with time zone',\n    'time',\n    'timetz',\n    'time with time zone',\n    'interval',\n    'uuid',\n    'json',\n    'jsonb',\n    'xml',\n    'inet',\n    'cidr',\n    'macaddr',\n    'macaddr8',\n    'smallserial',\n    'serial',\n    'bigserial',\n    'serial2',\n    'serial4',\n    'serial8',\n    'varchar',\n    'char',\n    'character',\n    'character varying',\n    'bpchar',\n    'numeric',\n    'decimal',\n    'bit',\n    'varbit',\n    'bit varying',\n]);\n\nconst POSTGRES_PARAM_ALLOWED: ReadonlySet<string> = new Set([\n    'varchar',\n    'char',\n    'character',\n    'character varying',\n    'bpchar',\n    'numeric',\n    'decimal',\n    'bit',\n    'varbit',\n    'bit varying',\n    'time',\n    'timetz',\n    'timestamp',\n    'timestamptz',\n    'interval',\n]);\n\n/** Whether the string is a valid Postgres 18 column type. */\nexport function isValidPostgresType(typeStr: string): boolean {\n    let type = typeStr.trim().toLowerCase().replace(/\\s+/g, ' ');\n\n    /// Strip one or more trailing array markers (`[]`, `[3]`).\n    type = type.replace(/(\\s*\\[\\s*\\d*\\s*\\])+$/, '').trim();\n\n    const paramMatch = /^(.*?)\\(([^)]*)\\)$/.exec(type);\n    if (paramMatch) {\n        const base = paramMatch[1].trim();\n        const params = paramMatch[2].trim();\n        return POSTGRES_PARAM_ALLOWED.has(base) && /^\\d+(\\s*,\\s*\\d+)?$/.test(params);\n    }\n\n    return POSTGRES_EXACT.has(type);\n}\n"]}

package/dist/src/validate.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Top-level validation: load a dataset root (Layer 1) and run the semantic
+ * rules (Layer 2), aggregating every violation.
+ */
+import { ValidationResult } from './model';
+/**
+ * Validate a dataset root.
+ *
+ * @param rootDir Path to the dataset root.
+ * @returns The aggregate result. `ok` is false when any error-level violation exists.
+ * @throws Error When `rootDir` is not an existing directory.
+ */
+export declare function validateRoot(rootDir: string): ValidationResult;

package/dist/src/validate.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * Top-level validation: load a dataset root (Layer 1) and run the semantic
+ * rules (Layer 2), aggregating every violation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRoot = validateRoot;
+const loader_1 = require("./loader");
+const world_1 = require("./world");
+/**
+ * Validate a dataset root.
+ *
+ * @param rootDir Path to the dataset root.
+ * @returns The aggregate result. `ok` is false when any error-level violation exists.
+ * @throws Error When `rootDir` is not an existing directory.
+ */
+function validateRoot(rootDir) {
+    const { world, violations, } = (0, loader_1.loadRoot)(rootDir);
+    const semantic = (0, world_1.runSemanticRules)(world);
+    const all = [
+        ...violations,
+        ...semantic,
+    ];
+    const ok = !all.some((violation) => violation.level === 'error');
+    return {
+        ok,
+        violations: all,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/world.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The world: the in-memory representation of a loaded dataset root, plus the
+ * top-level semantic-rule runner.
+ *
+ * A `World` holds every schema and every table (as a concrete
+ * `TableTypeBase` instance). `runSemanticRules` walks the world, asking each
+ * structurally-valid table for its intra-table and cross-file violations,
+ * then appends the one global rule that has to see the whole graph at once
+ * (cycle detection).
+ */
+import { SchemaDescription, Violation } from './model';
+import type { TableTypeBase } from './table-type';
+/** A schema loaded from disk. */
+export interface LoadedSchema {
+    /** Schema name (the folder name). */
+    readonly name: string;
+    /** Absolute path to the schema folder. */
+    readonly dirPath: string;
+    /** Description from `<schema>.json`, or null if that file is missing. */
+    readonly description: SchemaDescription | null;
+    /** Tables in this schema. */
+    readonly tables: TableTypeBase[];
+}
+/** The whole loaded dataset root. */
+export interface World {
+    /** Absolute path to the root. */
+    readonly rootDir: string;
+    /** Schemas keyed by name. */
+    readonly schemas: Map<string, LoadedSchema>;
+    /** Tables keyed by `schema.table`. */
+    readonly tables: Map<string, TableTypeBase>;
+}
+/**
+ * Run all semantic rules over a world.
+ *
+ * @param world The loaded dataset root.
+ * @returns Every semantic violation found.
+ */
+export declare function runSemanticRules(world: World): Violation[];

package/dist/src/world.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * The world: the in-memory representation of a loaded dataset root, plus the
+ * top-level semantic-rule runner.
+ *
+ * A `World` holds every schema and every table (as a concrete
+ * `TableTypeBase` instance). `runSemanticRules` walks the world, asking each
+ * structurally-valid table for its intra-table and cross-file violations,
+ * then appends the one global rule that has to see the whole graph at once
+ * (cycle detection).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSemanticRules = runSemanticRules;
+/// DEPENDENCY_GRAPH_ACYCLIC — the dependsOn graph has no cycles.
+///
+/// Standard three-colour DFS. Each back-edge (a dependency pointing at a table
+/// still on the current stack) closes a cycle and is detected exactly once,
+/// because every table is coloured grey then black a single time. This rule
+/// stays a free function because it operates on the whole graph at once, not
+/// on any single table in isolation.
+function acyclicViolations(world) {
+    const violations = [];
+    const white = new Set(world.tables.keys());
+    const gray = new Set();
+    const visit = (table, stack) => {
+        const node = table.qualifiedName;
+        white.delete(node);
+        gray.add(node);
+        stack.push(node);
+        for (const dependency of table.definition.dependsOn) {
+            const dependencyTable = world.tables.get(dependency);
+            if (dependencyTable === undefined) {
+                continue;
+            }
+            if (gray.has(dependency)) {
+                const cycle = [
+                    ...stack.slice(stack.indexOf(dependency)),
+                    dependency,
+                ];
+                violations.push({
+                    level: 'error',
+                    code: 'DEPENDENCY_GRAPH_ACYCLIC',
+                    schema: table.schema,
+                    table: table.name,
+                    path: table.filePath,
+                    field: 'dependsOn',
+                    message: `dependency cycle detected: ${cycle.join(' -> ')}`,
+                });
+            }
+            else if (white.has(dependency)) {
+                visit(dependencyTable, stack);
+            }
+        }
+        stack.pop();
+        gray.delete(node);
+    };
+    for (const table of world.tables.values()) {
+        if (white.has(table.qualifiedName)) {
+            visit(table, []);
+        }
+    }
+    return violations;
+}
+/**
+ * Run all semantic rules over a world.
+ *
+ * @param world The loaded dataset root.
+ * @returns Every semantic violation found.
+ */
+function runSemanticRules(world) {
+    const violations = [];
+    for (const table of world.tables.values()) {
+        if (!table.structurallyValid) {
+            continue;
+        }
+        violations.push(...table.intraTableViolations());
+        violations.push(...table.crossFileViolations(world));
+    }
+    violations.push(...acyclicViolations(world));
+    return violations;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"world.js","sourceRoot":"","sources":["../../src/world.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;AAkGH,4CAWC;AAxED,iEAAiE;AACjE,GAAG;AACH,+EAA+E;AAC/E,4EAA4E;AAC5E,4EAA4E;AAC5E,6EAA6E;AAC7E,qCAAqC;AACrC,SAAS,iBAAiB,CAAC,KAAY;IACnC,MAAM,UAAU,GAAgB,EAAE,CAAC;IACnC,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;IAC3C,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAE/B,MAAM,KAAK,GAAG,CAAC,KAAoB,EAAE,KAAe,EAAQ,EAAE;QAC1D,MAAM,IAAI,GAAG,KAAK,CAAC,aAAa,CAAC;QACjC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACnB,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACf,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAEjB,KAAK,MAAM,UAAU,IAAI,KAAK,CAAC,UAAU,CAAC,SAAS,EAAE,CAAC;YAClD,MAAM,eAAe,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;YACrD,IAAI,eAAe,KAAK,SAAS,EAAE,CAAC;gBAChC,SAAS;YACb,CAAC;YACD,IAAI,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC;gBACvB,MAAM,KAAK,GAAG;oBACV,GAAG,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;oBACzC,UAAU;iBACb,CAAC;gBACF,UAAU,CAAC,IAAI,CAAC;oBACZ,KAAK,EAAE,OAAO;oBACd,IAAI,EAAE,0BAA0B;oBAChC,MAAM,EAAE,KAAK,CAAC,MAAM;oBACpB,KAAK,EAAE,KAAK,CAAC,IAAI;oBACjB,IAAI,EAAE,KAAK,CAAC,QAAQ;oBACpB,KAAK,EAAE,WAAW;oBAClB,OAAO,EAAE,8BAA8B,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;iBAC9D,CAAC,CAAC;YACP,CAAC;iBAAM,IAAI,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC;gBAC/B,KAAK,CAAC,eAAe,EAAE,KAAK,CAAC,CAAC;YAClC,CAAC;QACL,CAAC;QAED,KAAK,CAAC,GAAG,EAAE,CAAC;QACZ,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACtB,CAAC,CAAC;IAEF,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC;QACxC,IAAI,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,aAAa,CAAC,EAAE,CAAC;YACjC,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACrB,CAAC;IACL,CAAC;IAED,OAAO,UAAU,CAAC;AACtB,CAAC;AAED;;;;;GAKG;AACH,SAAgB,gBAAgB,CAAC,KAAY;IACzC,MAAM,UAAU,GAAgB,EAAE,CAAC;IACnC,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC;QACxC,IAAI,CAAC,KAAK,CAAC,iBAAiB,EAAE,CAAC;YAC3B,SAAS;QACb,CAAC;QACD,UAAU,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,oBAAoB,EAAE,CAAC,CAAC;QACjD,UAAU,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC,CAAC;IACzD,CAAC;IACD,UAAU,CAAC,IAAI,CAAC,GAAG,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC;IAC7C,OAAO,UAAU,CAAC;AACtB,CAAC","sourcesContent":["/**\n * The world: the in-memory representation of a loaded dataset root, plus the\n * top-level semantic-rule runner.\n *\n * A `World` holds every schema and every table (as a concrete\n * `TableTypeBase` instance). `runSemanticRules` walks the world, asking each\n * structurally-valid table for its intra-table and cross-file violations,\n * then appends the one global rule that has to see the whole graph at once\n * (cycle detection).\n */\n\nimport {\n    SchemaDescription,\n    Violation,\n} from './model';\nimport type {\n    TableTypeBase,\n} from './table-type';\n\n/** A schema loaded from disk. */\nexport interface LoadedSchema {\n    /** Schema name (the folder name). */\n    readonly name: string;\n\n    /** Absolute path to the schema folder. */\n    readonly dirPath: string;\n\n    /** Description from `<schema>.json`, or null if that file is missing. */\n    readonly description: SchemaDescription | null;\n\n    /** Tables in this schema. */\n    readonly tables: TableTypeBase[];\n}\n\n/** The whole loaded dataset root. */\nexport interface World {\n    /** Absolute path to the root. */\n    readonly rootDir: string;\n\n    /** Schemas keyed by name. */\n    readonly schemas: Map<string, LoadedSchema>;\n\n    /** Tables keyed by `schema.table`. */\n    readonly tables: Map<string, TableTypeBase>;\n}\n\n/// DEPENDENCY_GRAPH_ACYCLIC — the dependsOn graph has no cycles.\n///\n/// Standard three-colour DFS. Each back-edge (a dependency pointing at a table\n/// still on the current stack) closes a cycle and is detected exactly once,\n/// because every table is coloured grey then black a single time. This rule\n/// stays a free function because it operates on the whole graph at once, not\n/// on any single table in isolation.\nfunction acyclicViolations(world: World): Violation[] {\n    const violations: Violation[] = [];\n    const white = new Set(world.tables.keys());\n    const gray = new Set<string>();\n\n    const visit = (table: TableTypeBase, stack: string[]): void => {\n        const node = table.qualifiedName;\n        white.delete(node);\n        gray.add(node);\n        stack.push(node);\n\n        for (const dependency of table.definition.dependsOn) {\n            const dependencyTable = world.tables.get(dependency);\n            if (dependencyTable === undefined) {\n                continue;\n            }\n            if (gray.has(dependency)) {\n                const cycle = [\n                    ...stack.slice(stack.indexOf(dependency)),\n                    dependency,\n                ];\n                violations.push({\n                    level: 'error',\n                    code: 'DEPENDENCY_GRAPH_ACYCLIC',\n                    schema: table.schema,\n                    table: table.name,\n                    path: table.filePath,\n                    field: 'dependsOn',\n                    message: `dependency cycle detected: ${cycle.join(' -> ')}`,\n                });\n            } else if (white.has(dependency)) {\n                visit(dependencyTable, stack);\n            }\n        }\n\n        stack.pop();\n        gray.delete(node);\n    };\n\n    for (const table of world.tables.values()) {\n        if (white.has(table.qualifiedName)) {\n            visit(table, []);\n        }\n    }\n\n    return violations;\n}\n\n/**\n * Run all semantic rules over a world.\n *\n * @param world The loaded dataset root.\n * @returns Every semantic violation found.\n */\nexport function runSemanticRules(world: World): Violation[] {\n    const violations: Violation[] = [];\n    for (const table of world.tables.values()) {\n        if (!table.structurallyValid) {\n            continue;\n        }\n        violations.push(...table.intraTableViolations());\n        violations.push(...table.crossFileViolations(world));\n    }\n    violations.push(...acyclicViolations(world));\n    return violations;\n}\n"]}