@xdbml/parse 0.5.1 → 0.6.1

package/dist/keywords.js

@@ -161,6 +161,15 @@ export const BSON_TYPES = [
  * are left out for that reason. The list is a convenience, not a
  * vocabulary: a name missing from it is still a valid type.
  * ----------------------------------------------------------------------- */
+/* -------------------------------------------------------------------------
+ * Entity-body block keywords (TextMate only)
+ *
+ * The words that open a block inside an entity body. They also appear in
+ * SETTING_KEYS above, which colors them in Monaco; the TextMate grammar
+ * colors setting keys only inside `[ ]`, so it matches these separately,
+ * and only when `{` follows, since a field may carry one of these names.
+ * ----------------------------------------------------------------------- */
+export const BLOCK_KEYWORDS = ['indexes', 'checks', 'constraints', 'records'];
 export const TARGET_NATIVE_TYPES = [
     // Oracle
     'number', 'binary_float', 'binary_double', 'clob', 'nclob', 'bfile',
@@ -286,6 +295,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/monarch.js

@@ -156,6 +156,10 @@ export const xdbmlMonarchTokensProvider = {
             [/#[0-9A-Fa-f]{3,8}\b/, 'number.hex'],
             // x_ custom property identifiers
             [/\bx_[a-zA-Z0-9_]+/, 'identifier.custom-property'],
+            // Spec §3.10 (v0.6.1): `Note` starts a note only before ':' or '{',
+            // or at the top level before a name and '{'. Anywhere else it names a
+            // field, so it takes the identifier color like any other field name.
+            [/note(?![\w$])(?!\s*[:{])(?!\s+(?:[A-Za-z_][\w$]*|"[^"]*")\s*\{)/, 'identifier'],
             // Identifiers and keyword recognition.
             // The parser is the authority on keyword vs identifier disambiguation;
             // Monarch does coarse highlighting based on lowercase comparison.

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' | 'possible-type-typo' | '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' | 'duplicate-unique-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' | 'source-query-in-settings' | 'duplicate-source-query';
 /**
  * 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,8 @@ 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";
+import { checkViews } from "./views.js";
 /**
  * Read-only handle on the collected symbol table.
  *
@@ -228,6 +230,10 @@ 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));
+    // Pass 6: view source queries (spec §14.7).
+    diagnostics.push(...checkViews(flat));
     return { diagnostics, symbols };
 }
 /* -------------------------------------------------------------------------

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.1";
 /** Compare dotted version strings numerically: -1, 0 or 1. */
 export declare function compareVersions(a: string, b: string): number;
 export declare class Parser {
@@ -64,6 +64,30 @@ export declare class Parser {
     private check;
     private match;
     private expect;
+    /**
+     * Skip the commas and semicolons of a list body. In a list body a comma
+     * or a semicolon may stand between items, before the first and after the
+     * last, any number of times, with no meaning of its own (spec §3.9).
+     */
+    private skipListSeparators;
+    /**
+     * Whether the current token starts a note element: `Note` followed by
+     * `:` or `{`. Anywhere else `note` names a field (spec §3.10), as in
+     * DBML; a field declaration never has `:` or `{` right after its name.
+     */
+    private atNoteElement;
+    /**
+     * Whether the current token is the body keyword `word` opening its block,
+     * that is, followed by `{` (spec §3.10). Before a type, the same word
+     * names a field.
+     */
+    private atBlockKeyword;
+    /**
+     * A line such as `materialized: true` in a body is a setting written in
+     * the wrong place: a field declaration never has `:` after its name.
+     * Name the brackets in the error rather than reporting a missing type.
+     */
+    private rejectSettingInBody;
     private spanFrom;
     parseDocument(): XDbmlDocument;
     private parseVersionDeclaration;
@@ -326,6 +350,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.1';
 /** Compare dotted version strings numerically: -1, 0 or 1. */
 export function compareVersions(a, b) {
     const pa = a.split('.').map((n) => Number(n) || 0);
@@ -168,6 +169,50 @@ export class Parser {
         const t = this.peek();
         throw new ParseError(`${msg} (got ${t.kind} ${JSON.stringify(t.text)})`, t.start);
     }
+    /* ----- list bodies and body keywords (spec §3.9, §3.10, v0.6.1) ----- */
+    /**
+     * Skip the commas and semicolons of a list body. In a list body a comma
+     * or a semicolon may stand between items, before the first and after the
+     * last, any number of times, with no meaning of its own (spec §3.9).
+     */
+    skipListSeparators() {
+        while (this.check(TokenKind.Comma) || this.check(TokenKind.Semicolon))
+            this.advance();
+    }
+    /**
+     * Whether the current token starts a note element: `Note` followed by
+     * `:` or `{`. Anywhere else `note` names a field (spec §3.10), as in
+     * DBML; a field declaration never has `:` or `{` right after its name.
+     */
+    atNoteElement() {
+        if (!isKw(this.peek(), 'note'))
+            return false;
+        const next = this.peek(1).kind;
+        return next === TokenKind.Colon || next === TokenKind.LBrace;
+    }
+    /**
+     * Whether the current token is the body keyword `word` opening its block,
+     * that is, followed by `{` (spec §3.10). Before a type, the same word
+     * names a field.
+     */
+    atBlockKeyword(word) {
+        return isKw(this.peek(), word) && this.peek(1).kind === TokenKind.LBrace;
+    }
+    /**
+     * A line such as `materialized: true` in a body is a setting written in
+     * the wrong place: a field declaration never has `:` after its name.
+     * Name the brackets in the error rather than reporting a missing type.
+     */
+    rejectSettingInBody(construct, name) {
+        const t = this.peek();
+        if (t.kind !== TokenKind.Identifier || this.peek(1).kind !== TokenKind.Colon)
+            return;
+        const where = construct === 'View'
+            ? 'The body of a View holds source_query:, fields and Note: (spec §14.1, §14.2).'
+            : `The body of ${construct === 'Entity' ? 'an' : 'a'} ${construct} holds fields, blocks and Note:.`;
+        throw new ParseError(`'${t.text}:' is a setting: write it in the brackets after the ${construct} name, ` +
+            `as in ${construct} ${name} [${t.text}: ...] { ... }. ${where}`, t.start);
+    }
     spanFrom(start) {
         // span end = end-position of the previously consumed token if any
         const prev = this.idx > 0 ? this.tokens[this.idx - 1] : this.tokens[0];
@@ -191,13 +236,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() {
@@ -205,14 +253,22 @@ export class Parser {
         this.advance(); // xdbml
         this.expect(TokenKind.Colon, "Expected ':' after 'xdbml'");
         const numTok = this.expect(TokenKind.NumberLiteral, 'Expected version number');
-        if (compareVersions(numTok.text, SUPPORTED_XDBML_VERSION) > 0) {
-            throw new ParseError(`This document declares 'xdbml: ${numTok.text}', which is newer than the ` +
+        // Spec §4: MAJOR.MINOR[.PATCH]. The lexer reads `0.6` as one number,
+        // so a patch number arrives as a dot and a second number. `xdbml: 0.6`
+        // compares as 0.6.0, so it stays valid under every 0.6.x parser.
+        let version = numTok.text;
+        if (this.check(TokenKind.Dot) && this.peek(1).kind === TokenKind.NumberLiteral) {
+            this.advance(); // .
+            version += `.${this.advance().text}`;
+        }
+        if (compareVersions(version, SUPPORTED_XDBML_VERSION) > 0) {
+            throw new ParseError(`This document declares 'xdbml: ${version}', which is newer than the ` +
                 `latest version this parser supports (${SUPPORTED_XDBML_VERSION}). ` +
                 'Use a newer parser, or declare a supported version.', numTok.start, 'unsupported-version');
         }
         return {
             kind: 'VersionDeclaration',
-            version: numTok.text,
+            version,
             span: this.spanFrom(start),
         };
     }
@@ -279,7 +335,10 @@ export class Parser {
         const name = this.parseIdentLikeName('project name');
         this.expect(TokenKind.LBrace, "Expected '{' after Project name");
         const body = [];
-        while (!this.check(TokenKind.RBrace) && !this.check(TokenKind.EOF)) {
+        for (;;) {
+            this.skipListSeparators();
+            if (this.check(TokenKind.RBrace) || this.check(TokenKind.EOF))
+                break;
             // Project body is either an inline Note block or a setting line.
             if (isKw(this.peek(), 'note')) {
                 body.push(this.parseNoteBlockOrSetting());
@@ -439,7 +498,7 @@ export class Parser {
         }
         const settings = this.maybeSettingsBlock();
         this.expect(TokenKind.LBrace, "Expected '{' after entity name");
-        const body = this.parseEntityBody();
+        const body = this.parseEntityBody(canonEntityKw(kwTok.text), name);
         this.expect(TokenKind.RBrace, "Expected '}' closing entity");
         return {
             kind: 'EntityDeclaration',
@@ -473,27 +532,37 @@ export class Parser {
         }
         return name;
     }
-    parseEntityBody() {
+    parseEntityBody(construct, name) {
         const body = [];
-        while (!this.check(TokenKind.RBrace) && !this.check(TokenKind.EOF)) {
+        for (;;) {
+            this.skipListSeparators();
+            if (this.check(TokenKind.RBrace) || this.check(TokenKind.EOF))
+                break;
             const t = this.peek();
-            const k = kw(t);
-            if (k === 'note') {
+            // Spec §3.10: each body keyword starts its element only when the
+            // token the element needs follows it; otherwise it names a field,
+            // as in DBML. (v0.6 §10.1 did this for `constraints`; v0.6.1 does it
+            // for `Note`, `indexes`, `checks` and `records`.)
+            if (this.atNoteElement()) {
                 body.push(this.parseNoteBlockOrSetting());
             }
-            else if (k === 'indexes') {
+            else if (this.atBlockKeyword('indexes')) {
                 body.push(this.parseIndexes());
             }
-            else if (k === 'checks') {
+            else if (this.atBlockKeyword('checks')) {
                 body.push(this.parseChecks());
             }
-            else if (k === 'records') {
+            else if (this.atBlockKeyword('constraints')) {
+                body.push(this.parseConstraints());
+            }
+            else if (this.atBlockKeyword('records')) {
                 body.push(this.parseRecordsBlock());
             }
             else if (t.kind === TokenKind.Tilde) {
                 body.push(this.parsePartialInjection());
             }
             else {
+                this.rejectSettingInBody(construct, name);
                 body.push(this.parseFieldDeclaration());
             }
         }
@@ -983,10 +1052,12 @@ export class Parser {
         const kwTok = this.advance();
         this.expect(TokenKind.LBrace, "Expected '{' after object keyword");
         const fields = [];
-        while (!this.check(TokenKind.RBrace) && !this.check(TokenKind.EOF)) {
+        for (;;) {
+            this.skipListSeparators();
+            if (this.check(TokenKind.RBrace) || this.check(TokenKind.EOF))
+                break;
             const t = this.peek();
-            const k = kw(t);
-            if (k === 'note') {
+            if (this.atNoteElement()) {
                 fields.push(this.parseNoteBlockOrSetting());
             }
             else if (t.kind === TokenKind.Tilde) {
@@ -1207,7 +1278,10 @@ export class Parser {
         this.advance(); // oneOf | anyOf | allOf
         this.expect(TokenKind.LBrace, `Expected '{' after ${flavor}`);
         const alternatives = [];
-        while (!this.check(TokenKind.RBrace) && !this.check(TokenKind.EOF)) {
+        for (;;) {
+            this.skipListSeparators();
+            if (this.check(TokenKind.RBrace) || this.check(TokenKind.EOF))
+                break;
             alternatives.push(this.parsePolymorphicAlternative());
         }
         this.expect(TokenKind.RBrace, `Expected '}' closing ${flavor}`);
@@ -1240,10 +1314,12 @@ export class Parser {
         if (this.check(TokenKind.LBrace)) {
             this.advance();
             fields = [];
-            while (!this.check(TokenKind.RBrace) && !this.check(TokenKind.EOF)) {
+            for (;;) {
+                this.skipListSeparators();
+                if (this.check(TokenKind.RBrace) || this.check(TokenKind.EOF))
+                    break;
                 const t = this.peek();
-                const k = kw(t);
-                if (k === 'note') {
+                if (this.atNoteElement()) {
                     fields.push(this.parseNoteBlockOrSetting());
                 }
                 else if (t.kind === TokenKind.Tilde) {
@@ -1374,10 +1450,12 @@ export class Parser {
     finishObjectTypeDecl(start, name, settings) {
         this.expect(TokenKind.LBrace, "Expected '{' after Type name");
         const body = [];
-        while (!this.check(TokenKind.RBrace) && !this.check(TokenKind.EOF)) {
+        for (;;) {
+            this.skipListSeparators();
+            if (this.check(TokenKind.RBrace) || this.check(TokenKind.EOF))
+                break;
             const t = this.peek();
-            const k = kw(t);
-            if (k === 'note') {
+            if (this.atNoteElement()) {
                 body.push(this.parseNoteBlockOrSetting());
             }
             else if (t.kind === TokenKind.Tilde) {
@@ -1403,7 +1481,7 @@ export class Parser {
         const name = this.parseIdentLikeName('edge name');
         const settings = this.maybeSettingsBlock();
         this.expect(TokenKind.LBrace, "Expected '{' after Edge settings");
-        const body = this.parseEntityBody();
+        const body = this.parseEntityBody('Edge', name);
         this.expect(TokenKind.RBrace, "Expected '}' closing Edge");
         return {
             kind: 'EdgeDeclaration',
@@ -1421,16 +1499,22 @@ export class Parser {
         const settings = this.maybeSettingsBlock();
         this.expect(TokenKind.LBrace, "Expected '{' after View name");
         const body = [];
-        while (!this.check(TokenKind.RBrace) && !this.check(TokenKind.EOF)) {
-            const t = this.peek();
-            const k = kw(t);
-            if (k === 'note') {
+        for (;;) {
+            this.skipListSeparators();
+            if (this.check(TokenKind.RBrace) || this.check(TokenKind.EOF))
+                break;
+            // Spec §3.10: `Note` and `source_query` start their elements only
+            // before `:` (or `{` for a note); otherwise they name a field.
+            if (this.atNoteElement()) {
                 body.push(this.parseNoteBlockOrSetting());
             }
-            else if (k === 'source_query') {
+            else if (isKw(this.peek(), 'source_query') && this.peek(1).kind === TokenKind.Colon) {
                 body.push(this.parseSourceQueryItem());
             }
             else {
+                // Spec §14.2: `materialized: true` and the other settings go in
+                // the brackets, never in the body.
+                this.rejectSettingInBody('View', name);
                 body.push(this.parseFieldDeclaration());
             }
         }
@@ -1471,7 +1555,10 @@ export class Parser {
         }
         this.expect(TokenKind.LBrace, "Expected '{' after enum name");
         const values = [];
-        while (!this.check(TokenKind.RBrace) && !this.check(TokenKind.EOF)) {
+        for (;;) {
+            this.skipListSeparators();
+            if (this.check(TokenKind.RBrace) || this.check(TokenKind.EOF))
+                break;
             const vStart = this.peek().start;
             const vt = this.peek();
             let vname;
@@ -1745,7 +1832,7 @@ export class Parser {
         const name = this.parseIdentLikeName('TablePartial name');
         const settings = this.maybeSettingsBlock();
         this.expect(TokenKind.LBrace, "Expected '{' after TablePartial name");
-        const body = this.parseEntityBody();
+        const body = this.parseEntityBody('TablePartial', name);
         this.expect(TokenKind.RBrace, "Expected '}' closing TablePartial");
         return {
             kind: 'TablePartialDeclaration',
@@ -1860,6 +1947,14 @@ export class Parser {
         this.expect(TokenKind.LBrace, "Expected '{' after indexes");
         const entries = [];
         while (!this.check(TokenKind.RBrace) && !this.check(TokenKind.EOF)) {
+            // Spec §3.9: `indexes` is not a list body. `email, name` may be meant
+            // as the composite index `(email, name)`, so a separator between
+            // entries stays an error rather than declaring two indexes.
+            const t = this.peek();
+            if (t.kind === TokenKind.Comma || t.kind === TokenKind.Semicolon) {
+                throw new ParseError(`Unexpected '${t.text}' in indexes: write one index per line, and a composite ` +
+                    'index in parentheses, as in (email, name) (spec §3.9).', t.start);
+            }
             entries.push(this.parseIndexEntry());
         }
         this.expect(TokenKind.RBrace, "Expected '}' closing indexes");
@@ -1919,7 +2014,10 @@ export class Parser {
         this.advance(); // checks
         this.expect(TokenKind.LBrace, "Expected '{' after checks");
         const entries = [];
-        while (!this.check(TokenKind.RBrace) && !this.check(TokenKind.EOF)) {
+        for (;;) {
+            this.skipListSeparators();
+            if (this.check(TokenKind.RBrace) || this.check(TokenKind.EOF))
+                break;
             entries.push(this.parseCheckEntry());
         }
         this.expect(TokenKind.RBrace, "Expected '}' closing checks");
@@ -1932,17 +2030,74 @@ 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 = [];
+        for (;;) {
+            this.skipListSeparators();
+            if (this.check(TokenKind.RBrace) || this.check(TokenKind.EOF))
+                break;
+            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/dist/views.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Views (spec §14): the source query and the checks of §14.7.
+ *
+ * A View's source query is a body element, `source_query: '...'`, at most
+ * once (§14.3). The grammar of v0.6.0 also accepted `source_query` in the
+ * settings brackets; since v0.6.1 that form is not the view's source query
+ * and draws a warning, so a document valid under v0.6.0 stays valid.
+ *
+ * `viewSourceQuery()` is the normalized AST of §28.7: the one source query
+ * of a View, the first `source_query:` element of its body. Consumers such
+ * as the playground inspector read it rather than walking the body.
+ */
+import type { SourceQueryItem, ViewDeclaration, XDbmlDocument } from './ast.ts';
+import type { Diagnostic } from './name-resolver.ts';
+/** The source query of a View (spec §14.3, §28.7), or undefined when it declares none. */
+export declare function viewSourceQuery(view: ViewDeclaration): SourceQueryItem | undefined;
+/** The warnings of spec §14.7. Both concern forms v0.6.0 accepted. */
+export declare function checkViews(doc: XDbmlDocument): Diagnostic[];

package/dist/views.js

@@ -0,0 +1,62 @@
+/**
+ * Views (spec §14): the source query and the checks of §14.7.
+ *
+ * A View's source query is a body element, `source_query: '...'`, at most
+ * once (§14.3). The grammar of v0.6.0 also accepted `source_query` in the
+ * settings brackets; since v0.6.1 that form is not the view's source query
+ * and draws a warning, so a document valid under v0.6.0 stays valid.
+ *
+ * `viewSourceQuery()` is the normalized AST of §28.7: the one source query
+ * of a View, the first `source_query:` element of its body. Consumers such
+ * as the playground inspector read it rather than walking the body.
+ */
+/** The source query of a View (spec §14.3, §28.7), or undefined when it declares none. */
+export function viewSourceQuery(view) {
+    for (const item of view.body) {
+        if (item.kind === 'SourceQueryItem')
+            return item;
+    }
+    return undefined;
+}
+function views(doc) {
+    const out = [];
+    for (const stmt of doc.statements) {
+        if (stmt.kind === 'ViewDeclaration')
+            out.push(stmt);
+        else if (stmt.kind === 'ContainerDeclaration') {
+            for (const item of stmt.body) {
+                if (item.kind === 'ViewDeclaration')
+                    out.push(item);
+            }
+        }
+    }
+    return out;
+}
+/** The warnings of spec §14.7. Both concern forms v0.6.0 accepted. */
+export function checkViews(doc) {
+    const diagnostics = [];
+    for (const view of views(doc)) {
+        for (const s of view.settings) {
+            if (s.name !== 'source_query')
+                continue;
+            diagnostics.push({
+                severity: 'warning',
+                code: 'source-query-in-settings',
+                message: `View '${view.name}' writes source_query in its settings, where it is not the view's ` +
+                    "source query. Move it into the body: View name { source_query: '...' ... } (spec §14.3).",
+                span: s.span,
+            });
+        }
+        const queries = view.body.filter((b) => b.kind === 'SourceQueryItem');
+        for (const extra of queries.slice(1)) {
+            diagnostics.push({
+                severity: 'warning',
+                code: 'duplicate-source-query',
+                message: `View '${view.name}' declares a second source query; the first one is the view's ` +
+                    'source query (spec §14.3).',
+                span: extra.span,
+            });
+        }
+    }
+    return diagnostics;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xdbml/parse",
-  "version": "0.5.1",
+  "version": "0.6.1",
   "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",