@xdbml/parse 0.5.0 → 0.6.0

package/dist/keywords.js

@@ -98,9 +98,15 @@ export const POLYMORPHISM_KEYWORDS = [
 /* -------------------------------------------------------------------------
  * Scalar and BSON types
  *
- * The parser accepts any identifier as a scalar type (open vocabulary),
- * so these lists drive color, not validation. Themes color them under
- * `storage.type` (TextMate) or `type` (Monarch).
+ * The parser accepts any identifier as a scalar type (open vocabulary,
+ * spec §1.2 principle 4), so these lists never reject a type name.
+ * They serve two purposes: themes color them under `storage.type`
+ * (TextMate) or `type` (Monarch), and the name resolver treats them as
+ * built-in names, which a Named Type cannot shadow (spec §15.2).
+ * Adding a name here therefore changes resolution as well as color: a
+ * document declaring `Type <that name>` would stop resolving to its own
+ * Type. Target-native names that only need color go in
+ * TARGET_NATIVE_TYPES below.
  * ----------------------------------------------------------------------- */
 export const SCALAR_TYPES = [
     // Integers
@@ -139,6 +145,51 @@ export const BSON_TYPES = [
     'long',
     'double',
 ];
+/* -------------------------------------------------------------------------
+ * Target-native types (highlighting only)
+ *
+ * Common type names of specific targets, colored like SCALAR_TYPES so
+ * that a physical model reads the same in the editor as a generic one.
+ * Unlike SCALAR_TYPES, these are not built-in names: the resolver
+ * passes them through like any other target-native name, and a Named
+ * Type or Enum may be declared under one of them.
+ *
+ * Coloring is position-independent (Monarch and TextMate both match
+ * the bare word), so a field named after a listed type is colored as a
+ * type too. Generic words that often name fields -- `point`, `line`,
+ * `box`, `path`, `circle`, `image`, `counter`, `duration`, `name` --
+ * are left out for that reason. The list is a convenience, not a
+ * vocabulary: a name missing from it is still a valid type.
+ * ----------------------------------------------------------------------- */
+export const TARGET_NATIVE_TYPES = [
+    // Oracle
+    'number', 'binary_float', 'binary_double', 'clob', 'nclob', 'bfile',
+    'raw', 'rowid', 'urowid', 'xmltype', 'sdo_geometry',
+    // Oracle, PostgreSQL, BigQuery, Databricks
+    'interval',
+    // PostgreSQL
+    'serial', 'smallserial', 'bigserial', 'serial2', 'serial4', 'serial8',
+    'int2', 'int4', 'int8', 'float4', 'float8', 'bytea', 'citext',
+    'inet', 'cidr', 'macaddr', 'macaddr8', 'tsvector', 'tsquery', 'hstore',
+    'jsonpath', 'timetz', 'varbit',
+    'int4range', 'int8range', 'numrange', 'tsrange', 'tstzrange', 'daterange',
+    // SQL Server
+    'uniqueidentifier', 'datetimeoffset', 'smalldatetime', 'rowversion',
+    'hierarchyid', 'sql_variant',
+    // Snowflake (plus `number`, `interval`, `geography`, `geometry`)
+    'timestamp_ntz', 'timestamp_ltz', 'timestamp_tz', 'vector',
+    // BigQuery, Avro, Protobuf
+    'float64', 'bignumeric', 'bigdecimal', 'bytes',
+    // Spatial, across several targets
+    'geometry', 'geography',
+    // Cassandra
+    'ascii', 'varint', 'timeuuid',
+    // Protobuf
+    'uint32', 'uint64', 'sint32', 'sint64',
+    'fixed32', 'fixed64', 'sfixed32', 'sfixed64',
+    // ClickHouse
+    'uint8', 'uint16', 'int16', 'float32',
+];
 /* -------------------------------------------------------------------------
  * Settings vocabulary
  *
@@ -235,6 +286,7 @@ export const SETTING_KEYS = [
     // Block keywords (entity-body or top-level)
     'indexes',
     'checks', // v0.2 §10: entity-level checks block
+    'constraints', // v0.6 §10: keys and checks block
     // Container settings
     'replication',
     'location',

package/dist/module-resolver.js

@@ -390,8 +390,18 @@ function findImportTarget(item, doc) {
         }
         return undefined;
     }
-    // Enum: top-level OR container-scoped.
+    // Enum: top-level OR container-scoped. A top-level Enum declared with
+    // a qualified name (`enum core.job_status`, the DBML form) matches its
+    // full dotted path and imports under its bare name, like the
+    // container-scoped form: the source container does not survive into
+    // the importing file (spec §27.16).
     if (item.elementType === 'enum') {
+        if (segments.length > 1) {
+            const qualifiedTopLevel = doc.statements.find((s) => s.kind === 'EnumDeclaration' && s.name === path);
+            if (qualifiedTopLevel && qualifiedTopLevel.kind === 'EnumDeclaration') {
+                return { ...qualifiedTopLevel, name: segments[segments.length - 1] };
+            }
+        }
         if (segments.length === 1) {
             return doc.statements.find((s) => s.kind === 'EnumDeclaration' && s.name === segments[0]);
         }

package/dist/monarch.d.ts

@@ -53,6 +53,7 @@ export interface XDbmlMonarchLanguage {
     polymorphismKeywords: string[];
     scalarTypes: string[];
     bsonTypes: string[];
+    nativeTypes: string[];
     settingFlags: string[];
     settingKeys: string[];
     granularityValues: string[];

package/dist/monarch.js

@@ -18,7 +18,7 @@
  * dependency on consumers that just want to parse. The Monaco types
  * are structurally compatible -- the consumer casts at the boundary.
  */
-import { CONTAINER_KEYWORDS, ENTITY_KEYWORDS, DECLARATION_KEYWORDS, STRUCTURAL_TYPE_KEYWORDS, POLYMORPHISM_KEYWORDS, SCALAR_TYPES, BSON_TYPES, SETTING_FLAGS, SETTING_KEYS, GRANULARITY_VALUES, } from "./keywords.js";
+import { CONTAINER_KEYWORDS, ENTITY_KEYWORDS, DECLARATION_KEYWORDS, STRUCTURAL_TYPE_KEYWORDS, POLYMORPHISM_KEYWORDS, SCALAR_TYPES, BSON_TYPES, TARGET_NATIVE_TYPES, SETTING_FLAGS, SETTING_KEYS, GRANULARITY_VALUES, } from "./keywords.js";
 /* -------------------------------------------------------------------------
  * Language configuration
  * ----------------------------------------------------------------------- */
@@ -102,6 +102,9 @@ export const xdbmlMonarchTokensProvider = {
     scalarTypes: [...SCALAR_TYPES],
     // BSON / document-store types
     bsonTypes: [...BSON_TYPES],
+    // Target-native types (Oracle `number`, PostgreSQL `serial`, ...):
+    // colored like scalar types, but not built-ins -- see keywords.ts.
+    nativeTypes: [...TARGET_NATIVE_TYPES],
     // Bare-flag settings: `pk`, `unique`, `not null`, etc.
     // `not null` and `primary key` are two words but tokenized one at a time
     // here -- the highlighter colors each as `keyword.setting`.
@@ -165,6 +168,7 @@ export const xdbmlMonarchTokensProvider = {
                         '@decls': 'keyword.declaration',
                         '@scalarTypes': 'type',
                         '@bsonTypes': 'type.bson',
+                        '@nativeTypes': 'type',
                         '@settingFlags': 'keyword.setting',
                         '@settingKeys': 'keyword.setting',
                         '@granularityValues': 'keyword.value',

package/dist/name-resolver.d.ts

@@ -67,7 +67,7 @@ export interface SymbolEntry {
  * Stable diagnostic code. Tooling can match on these to filter or style
  * messages without parsing the human-readable text.
  */
-export type DiagnosticCode = 'duplicate-declaration' | 'unresolved-type' | 'unresolved-entity' | 'unresolved-field' | 'unresolved-partial' | 'unresolved-tablegroup-member' | 'unresolved-records-entity' | 'unresolved-records-column' | 'empty-import' | 'invalid-nested-path' | 'foreign-master-composite' | 'foreign-master-duplicate-child' | 'foreign-master-without-ref' | 'construct-requires-version' | 'ambiguous-ref-endpoint' | 'invalid-constraint-type' | 'constraint-type-on-foreign-master' | 'invalid-undirected' | 'entity-level-many-to-many' | 'missing-supertype' | 'unresolved-supertype-group-member' | 'invalid-supertype-group-value' | 'duplicate-subtype' | 'supertype-is-subtype' | 'subtype-in-multiple-groups' | 'supertype-cycle' | 'supertype-attribute-redeclared' | 'discriminator-on-overlapping-group' | 'merge-without-roll-up' | 'empty-supertype-group';
+export type DiagnosticCode = 'duplicate-declaration' | 'unresolved-type' | 'possible-type-typo' | 'unresolved-key-field' | 'unresolved-index-field' | 'key-path-crosses-collection' | 'invalid-key-flags' | 'duplicate-primary-key' | 'null-in-primary-key' | 'duplicate-constraints-block' | 'ref-target-not-key' | 'unresolved-entity' | 'unresolved-field' | 'unresolved-partial' | 'unresolved-tablegroup-member' | 'unresolved-records-entity' | 'unresolved-records-column' | 'empty-import' | 'invalid-nested-path' | 'foreign-master-composite' | 'foreign-master-duplicate-child' | 'foreign-master-without-ref' | 'construct-requires-version' | 'ambiguous-ref-endpoint' | 'invalid-constraint-type' | 'constraint-type-on-foreign-master' | 'invalid-undirected' | 'entity-level-many-to-many' | 'missing-supertype' | 'unresolved-supertype-group-member' | 'invalid-supertype-group-value' | 'duplicate-subtype' | 'supertype-is-subtype' | 'subtype-in-multiple-groups' | 'supertype-cycle' | 'supertype-attribute-redeclared' | 'discriminator-on-overlapping-group' | 'merge-without-roll-up' | 'empty-supertype-group';
 /**
  * A single resolution diagnostic. Severity is currently always `error`,
  * but the field is included to leave room for future warnings (e.g.,

package/dist/name-resolver.js

@@ -42,6 +42,7 @@ import { SCALAR_TYPES, BSON_TYPES } from "./keywords.js";
 import { flatten } from "./module-resolver.js";
 import { checkRelationships } from "./relationships.js";
 import { checkSupertypeGroups } from "./supertypes.js";
+import { checkConstraints } from "./constraints.js";
 /**
  * Read-only handle on the collected symbol table.
  *
@@ -96,11 +97,18 @@ export class SymbolTable {
  * Built-in type recognition
  *
  * Field type expressions can name a builtin scalar (`int`, `varchar`),
- * a BSON type (`objectId`), or a user-defined Named Type (`Email`).
- * The parser doesn't distinguish at parse time -- they all land as
+ * a BSON type (`objectId`), a user-defined Named Type (`Email`) or Enum,
+ * or any other target-native type (`number`, `clob`, `serial`). The
+ * parser doesn't distinguish at parse time -- they all land as
  * ScalarType nodes (or NamedTypeReference in some contexts). The
- * resolver uses these sets to decide whether to look up a name in the
- * symbol table.
+ * resolver uses these sets only to skip the symbol-table lookup for
+ * names that can never be a Named Type reference.
+ *
+ * The sets are not a type vocabulary. Scalar type names pass through
+ * as written (spec §1.2, principle 4), so a name that is neither a
+ * builtin nor a declared Type or Enum is a target-native type, not an
+ * error. See `nearMissTypeName()` for the one diagnostic such a name
+ * can raise.
  *
  * Matching is case-insensitive: `Int`, `int`, `INT` all map to the same
  * builtin per spec §3.8.
@@ -112,6 +120,87 @@ const BUILTIN_TYPES = new Set([
 function isBuiltinType(name) {
     return BUILTIN_TYPES.has(name.toLowerCase());
 }
+/**
+ * The declared Types and Enums a bare type name can refer to. More than
+ * one entry means the name is declared in several containers (Enums can
+ * be container-scoped); the name still refers to a declaration, so it
+ * is neither a target-native type nor a near miss.
+ */
+function typeOrEnumDeclarations(name, symbols) {
+    const qualified = symbols.lookup(name);
+    if (qualified && (qualified.kind === 'type' || qualified.kind === 'enum'))
+        return [qualified];
+    return symbols.lookupAllBare(name).filter((e) => e.kind === 'type' || e.kind === 'enum');
+}
+/**
+ * Near-miss detection for target-native type names.
+ *
+ * A type name that is neither a builtin nor a declared Type or Enum is
+ * accepted as a target-native type. The one case worth flagging is a
+ * name that differs only slightly from a declared Type or Enum -- most
+ * likely a misspelling (`Adress` for `Address`, `email` for `Email`).
+ * Returns the declared name to suggest, or undefined when nothing is
+ * close enough.
+ *
+ * Comparison is case-insensitive, so a difference of case alone counts
+ * as a near miss (identifiers are case-sensitive, spec §3.8). The edit
+ * distance allowed grows with the length of the name: none beyond case
+ * for three characters or fewer, one edit up to seven characters, two
+ * edits from eight. An adjacent transposition counts as one edit.
+ */
+function nearMissTypeName(name, symbols) {
+    const lower = name.toLowerCase();
+    const maxDistance = lower.length <= 3 ? 0 : lower.length <= 7 ? 1 : 2;
+    // A qualified name (`core.job_stauts`) compares against qualified
+    // declarations, a bare name against bare ones.
+    const qualified = name.includes('.');
+    let best;
+    for (const entry of symbols.entries()) {
+        if (entry.kind !== 'type' && entry.kind !== 'enum')
+            continue;
+        const declared = qualified ? entry.qualifiedName : entry.name;
+        const candidate = declared.toLowerCase();
+        if (Math.abs(candidate.length - lower.length) > maxDistance)
+            continue;
+        const distance = editDistance(lower, candidate, maxDistance);
+        if (distance <= maxDistance && (!best || distance < best.distance)) {
+            best = { name: declared, distance };
+        }
+    }
+    return best?.name;
+}
+/**
+ * Optimal string alignment distance (Levenshtein plus adjacent
+ * transposition). Returns `limit + 1` as soon as every alignment of a
+ * row exceeds `limit`, since callers only compare against the limit.
+ */
+function editDistance(a, b, limit) {
+    const rows = a.length + 1;
+    const cols = b.length + 1;
+    const d = [];
+    for (let i = 0; i < rows; i++) {
+        d.push(new Array(cols).fill(0));
+        d[i][0] = i;
+    }
+    for (let j = 0; j < cols; j++)
+        d[0][j] = j;
+    for (let i = 1; i < rows; i++) {
+        let rowMin = Infinity;
+        for (let j = 1; j < cols; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            let v = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
+            if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+                v = Math.min(v, d[i - 2][j - 2] + 1);
+            }
+            d[i][j] = v;
+            if (v < rowMin)
+                rowMin = v;
+        }
+        if (rowMin > limit)
+            return limit + 1;
+    }
+    return d[rows - 1][cols - 1];
+}
 /* -------------------------------------------------------------------------
  * Main entry point
  * ----------------------------------------------------------------------- */
@@ -140,6 +229,8 @@ export function resolveNames(doc) {
     diagnostics.push(...checkRelationships(flat));
     // Pass 4: supertype group rules (spec 12.8).
     diagnostics.push(...checkSupertypeGroups(flat));
+    // Pass 5: constraints and referenced keys (spec §10.10, §11.17).
+    diagnostics.push(...checkConstraints(flat));
     return { diagnostics, symbols };
 }
 /* -------------------------------------------------------------------------
@@ -159,9 +250,20 @@ function addTopLevelDeclaration(stmt, entries, diagnostics, seen) {
         case 'TypeDeclaration':
             addEntry(stmt.name, undefined, 'type', stmt, stmt.span, entries, diagnostics, seen);
             return;
-        case 'EnumDeclaration':
-            addEntry(stmt.name, undefined, 'enum', stmt, stmt.span, entries, diagnostics, seen);
+        case 'EnumDeclaration': {
+            // `enum core.job_status { ... }` (the DBML form) files the Enum
+            // under container `core`, exactly as `Container core { Enum
+            // job_status { ... } }` does: same qualified name, same bare name,
+            // and declaring both is a duplicate (spec §16).
+            const dot = stmt.name.lastIndexOf('.');
+            if (dot > 0) {
+                addEntry(stmt.name.slice(dot + 1), stmt.name.slice(0, dot), 'enum', stmt, stmt.span, entries, diagnostics, seen);
+            }
+            else {
+                addEntry(stmt.name, undefined, 'enum', stmt, stmt.span, entries, diagnostics, seen);
+            }
             return;
+        }
         case 'EdgeDeclaration':
             addEntry(stmt.name, undefined, 'edge', stmt, stmt.span, entries, diagnostics, seen);
             return;
@@ -363,16 +465,18 @@ function resolveFieldDeclaration(field, symbols, diagnostics) {
 function resolveTypeExpression(expr, symbols, diagnostics) {
     switch (expr.kind) {
         case 'ScalarType':
-            // A ScalarType is either a builtin or a reference to a Named Type
-            // (the parser doesn't distinguish at parse time). Look up only
-            // when the name isn't a builtin.
-            if (!isBuiltinType(expr.name)) {
-                const found = symbols.lookup(expr.name) ?? symbols.lookupBare(expr.name);
-                if (!found || found.kind !== 'type') {
+            // A ScalarType is a builtin, a reference to a declared Type or
+            // Enum, or a target-native type passed through as written (spec
+            // §1.2, principle 4) -- the parser doesn't distinguish at parse
+            // time. A target-native name is valid; the only diagnostic is a
+            // warning when it is a near miss of a declared Type or Enum.
+            if (!isBuiltinType(expr.name) && typeOrEnumDeclarations(expr.name, symbols).length === 0) {
+                const suggestion = nearMissTypeName(expr.name, symbols);
+                if (suggestion) {
                     diagnostics.push({
-                        severity: 'error',
-                        code: 'unresolved-type',
-                        message: `Type '${expr.name}' is not a built-in type or declared Named Type.`,
+                        severity: 'warning',
+                        code: 'possible-type-typo',
+                        message: `Type '${expr.name}' is not declared; did you mean '${suggestion}'? Otherwise it is kept as a target-native type.`,
                         span: expr.span,
                     });
                 }
@@ -824,9 +928,18 @@ function dereferenceNamedType(type, symbols, depth) {
         return type;
     }
     const sym = symbols.lookup(name) ?? symbols.lookupBare(name);
+    if (type.kind === 'ScalarType' && (!sym || sym.kind !== 'type')) {
+        // An Enum or a target-native type: an opaque scalar, so a path that
+        // navigates into it gets the walker's shape diagnostic. A name
+        // declared as a Type or Enum in several containers stays unresolved.
+        if (typeOrEnumDeclarations(name, symbols).length > 1)
+            return undefined;
+        return type;
+    }
     if (!sym || sym.kind !== 'type' || sym.declaration.kind !== 'TypeDeclaration') {
-        // Unresolved -- the field-type pass will diagnose this. Return
-        // undefined so the walker bails without emitting a duplicate error.
+        // Unresolved Named Type reference -- the field-type pass diagnoses
+        // this. Return undefined so the walker bails without emitting a
+        // duplicate error.
         return undefined;
     }
     const td = sym.declaration;

package/dist/parser.d.ts

@@ -26,7 +26,7 @@ export declare class ParseError extends Error {
  * declaring a later version is refused (spec 4.1) rather than parsed with
  * semantics it does not have.
  */
-export declare const SUPPORTED_XDBML_VERSION = "0.5";
+export declare const SUPPORTED_XDBML_VERSION = "0.6";
 /** Compare dotted version strings numerically: -1, 0 or 1. */
 export declare function compareVersions(a: string, b: string): number;
 export declare class Parser {
@@ -326,6 +326,8 @@ export declare class Parser {
     private parseIndexComponent;
     private parseChecks;
     private parseCheckEntry;
+    private parseConstraints;
+    private parseKeyConstraintEntry;
     private maybeSettingsBlock;
     /**
      * A single setting. Forms:

package/dist/parser.js

@@ -9,6 +9,7 @@
  * semantic-analysis pass. The grammar test cases the parser passes are
  * the official xDBML example files in /examples.
  */
+import { markPrimaryKeyNotNull } from "./constraints.js";
 import { TokenKind, tokenize, } from "./lexer.js";
 import { resolveImport, classifyModuleSource, ModuleSourceError } from "./module-resolver.js";
 export class ParseError extends Error {
@@ -31,7 +32,7 @@ export class ParseError extends Error {
  * declaring a later version is refused (spec 4.1) rather than parsed with
  * semantics it does not have.
  */
-export const SUPPORTED_XDBML_VERSION = '0.5';
+export const SUPPORTED_XDBML_VERSION = '0.6';
 /** Compare dotted version strings numerically: -1, 0 or 1. */
 export function compareVersions(a, b) {
     const pa = a.split('.').map((n) => Number(n) || 0);
@@ -191,13 +192,16 @@ export class Parser {
         while (!this.check(TokenKind.EOF)) {
             statements.push(this.parseTopLevelStatement());
         }
-        return {
+        const doc = {
             kind: 'XDbmlDocument',
             version,
             experimental,
             statements,
             span: this.spanFrom(start),
         };
+        // v0.6 §10.4: primary key fields are not null in the AST.
+        markPrimaryKeyNotNull(doc);
+        return doc;
     }
     /* ----- version & experimental ----- */
     parseVersionDeclaration() {
@@ -487,6 +491,11 @@ export class Parser {
             else if (k === 'checks') {
                 body.push(this.parseChecks());
             }
+            else if (k === 'constraints' && this.peek(1).kind === TokenKind.LBrace) {
+                // v0.6 §10.1: a keyword only when `{` follows, so a field may keep
+                // the name `constraints`.
+                body.push(this.parseConstraints());
+            }
             else if (k === 'records') {
                 body.push(this.parseRecordsBlock());
             }
@@ -1289,7 +1298,14 @@ export class Parser {
             throw new ParseError(`Expected type name, got ${t.kind} ${JSON.stringify(t.text)}`, t.start);
         }
         this.advance();
-        const name = t.kind === TokenKind.QuotedIdentifier ? (t.value ?? '') : t.text;
+        let name = t.kind === TokenKind.QuotedIdentifier ? (t.value ?? '') : t.text;
+        // A qualified type name, `core.job_status`, names an Enum declared in
+        // a container (spec §16), or a target-native type such as
+        // `public.geometry` that passes through as written.
+        while (this.check(TokenKind.Dot)) {
+            this.advance();
+            name += `.${this.parseIdentLikeName('type name after dot')}`;
+        }
         let params;
         if (this.check(TokenKind.LParen)) {
             this.advance();
@@ -1455,7 +1471,13 @@ export class Parser {
     parseEnum() {
         const start = this.peek().start;
         const kwTok = this.advance(); // enum
-        const name = this.parseIdentLikeName('enum name');
+        // DBML form `enum core.job_status { ... }`: the qualifier names the
+        // container, as for a schema-qualified Table (spec §7.3, §16).
+        let name = this.parseIdentLikeName('enum name');
+        while (this.check(TokenKind.Dot)) {
+            this.advance();
+            name += `.${this.parseIdentLikeName('enum name after dot')}`;
+        }
         this.expect(TokenKind.LBrace, "Expected '{' after enum name");
         const values = [];
         while (!this.check(TokenKind.RBrace) && !this.check(TokenKind.EOF)) {
@@ -1919,17 +1941,71 @@ export class Parser {
     parseCheckEntry() {
         const start = this.peek().start;
         const exprTok = this.peek();
-        if (exprTok.kind !== TokenKind.ExpressionLiteral) {
-            throw new ParseError(`Expected backtick-wrapped check expression, got ${exprTok.kind} ${JSON.stringify(exprTok.text)}`, exprTok.start);
+        // v0.6 §10.5: single (or triple) quotes are the standard form and
+        // backticks an alias. The resolver rejects the quoted form in documents
+        // declaring an earlier version.
+        const quoted = exprTok.kind === TokenKind.StringLiteral || exprTok.kind === TokenKind.MultilineString;
+        if (exprTok.kind !== TokenKind.ExpressionLiteral && !quoted) {
+            throw new ParseError(`Expected a check expression in quotes or backticks, got ${exprTok.kind} ${JSON.stringify(exprTok.text)}`, exprTok.start);
         }
         this.advance();
-        // The expression is opaque to xDBML per spec §10.3. The value field of
-        // an ExpressionLiteral token already has the surrounding backticks stripped.
+        // The expression is opaque to xDBML (spec §10.5). The token value
+        // already has the delimiters stripped.
         const expression = exprTok.value ?? '';
         const settings = this.maybeSettingsBlock();
         return {
             kind: 'CheckEntry',
             expression,
+            delimiter: quoted ? 'quote' : 'backtick',
+            settings,
+            span: this.spanFrom(start),
+        };
+    }
+    /* ----- constraints block (v0.6 §10) ----- */
+    parseConstraints() {
+        const start = this.peek().start;
+        this.advance(); // constraints
+        this.expect(TokenKind.LBrace, "Expected '{' after constraints");
+        const entries = [];
+        while (!this.check(TokenKind.RBrace) && !this.check(TokenKind.EOF)) {
+            const t = this.peek();
+            if (t.kind === TokenKind.StringLiteral ||
+                t.kind === TokenKind.MultilineString ||
+                t.kind === TokenKind.ExpressionLiteral) {
+                entries.push(this.parseCheckEntry());
+            }
+            else {
+                entries.push(this.parseKeyConstraintEntry());
+            }
+        }
+        this.expect(TokenKind.RBrace, "Expected '}' closing constraints");
+        return {
+            kind: 'ConstraintsBlock',
+            entries,
+            span: this.spanFrom(start),
+        };
+    }
+    parseKeyConstraintEntry() {
+        const start = this.peek().start;
+        const fields = [];
+        let parenthesized = false;
+        if (this.check(TokenKind.LParen)) {
+            parenthesized = true;
+            this.advance(); // (
+            fields.push(this.parsePathSegments());
+            while (this.match(TokenKind.Comma)) {
+                fields.push(this.parsePathSegments());
+            }
+            this.expect(TokenKind.RParen, "Expected ')' closing the fields of a key");
+        }
+        else {
+            fields.push(this.parsePathSegments());
+        }
+        const settings = this.maybeSettingsBlock();
+        return {
+            kind: 'KeyConstraintEntry',
+            fields,
+            parenthesized,
             settings,
             span: this.spanFrom(start),
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xdbml/parse",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Parser for xDBML (eXtended Database Markup Language), a strict superset of DBML 3.13.6: tokenizer, parser, module resolver, and name resolver.",
   "license": "Apache-2.0",
   "author": "Hackolade",