@xdbml/parse 0.6.0 → 0.6.1

package/dist/constraints.js

@@ -437,17 +437,38 @@ export function checkConstraints(doc) {
             }
         }
         // One primary key, declared in one place (§10.4). Inline [pk] fields
-        // count as one declaration.
+        // count as one declaration. When the second declaration restates the
+        // same fields, say so: the fix is to delete one, not to look for
+        // another key.
         const own = bodyConstraints(decl.body, v06);
         const pks = own.filter((c) => c.kind === 'key' && c.keyKind === 'primary');
         for (const extra of pks.slice(1)) {
+            const first = pks[0];
             diagnostics.push({
                 severity: olderSeverity,
                 code: 'duplicate-primary-key',
-                message: `'${decl.name}' declares a second primary key; an entity has one, declared in one place.`,
+                message: sameKeyFields(first.fields, extra.fields)
+                    ? `'${decl.name}' declares its primary key (${first.fields.join(', ')}) twice: ` +
+                        `${twoForms(first, extra)}. Declare it in one place (spec §10.4).`
+                    : `'${decl.name}' declares a second primary key; an entity has one, declared in one place.`,
                 span: extra.span,
             });
         }
+        // Each unique key is declared once (§10.3, v0.6.1): a warning in every
+        // version, since earlier documents accept the repetition.
+        const uniques = own.filter((c) => c.kind === 'key' && c.keyKind === 'unique');
+        for (const [i, u] of uniques.entries()) {
+            const first = uniques.slice(0, i).find((prev) => sameKeyFields(prev.fields, u.fields));
+            if (!first)
+                continue;
+            diagnostics.push({
+                severity: 'warning',
+                code: 'duplicate-unique-key',
+                message: `'${decl.name}' declares the unique key (${first.fields.join(', ')}) twice: ` +
+                    `${twoForms(first, u)}. Declare it in one place (spec §10.3).`,
+                span: u.span,
+            });
+        }
         // `null` on a primary key field (§10.4).
         for (const pk of pks.slice(0, 1)) {
             for (const dotted of pk.fields) {
@@ -467,6 +488,32 @@ export function checkConstraints(doc) {
     diagnostics.push(...checkReferencedKeys(doc, olderSeverity));
     return diagnostics;
 }
+/** Two keys on the same fields, in any order, are the same key. */
+function sameKeyFields(a, b) {
+    if (a.length !== b.length)
+        return false;
+    const sa = [...a].sort();
+    const sb = [...b].sort();
+    return sa.every((f, i) => f === sb[i]);
+}
+/** How a key was written, for a message that names both declarations. */
+function keyForm(k) {
+    const flag = k.keyKind === 'primary' ? 'pk' : 'unique';
+    if (k.source === 'inline')
+        return `[${flag}] on ${k.fields.join(', ')}`;
+    if (k.source === 'indexes')
+        return `a ${flag} entry in indexes`;
+    return `a ${flag} line in constraints`;
+}
+/** Both declarations of a repeated key: "[pk] on id and a pk line in constraints". */
+function twoForms(a, b) {
+    const fa = keyForm(a);
+    const fb = keyForm(b);
+    if (fa !== fb)
+        return `${fa} and ${fb}`;
+    const flag = a.keyKind === 'primary' ? 'pk' : 'unique';
+    return a.source === 'indexes' ? `two ${flag} entries in indexes` : `two ${flag} lines in constraints`;
+}
 function entityIndex(doc) {
     const m = new Map();
     const bare = new Map();

package/dist/index.d.ts

@@ -32,6 +32,7 @@ export { flatten } from './module-resolver.ts';
 export { classifyModuleSource, isUrlKey, ModuleSourceError, } from './module-resolver.ts';
 export type { ModuleSource } from './module-resolver.ts';
 export { resolveNames, SymbolTable } from './name-resolver.ts';
+export { checkViews, viewSourceQuery } from './views.ts';
 export { bodyConstraints, checkConstraints, entityConstraints, isRelationalTarget, keyPathString, markPrimaryKeyNotNull, primaryKey, } from './constraints.ts';
 export type { CheckConstraint, Constraint, ConstraintSource, KeyConstraint } from './constraints.ts';
 export { FOREIGN_MASTER_FLAG, checkRelationships, hasForeignMasterFlag, isForeignMaster, pathToString, refChildEndpoint, refParentEndpoint, relationshipType, versionAtLeast, CONSTRAINT_TYPES, V04_RELATIONSHIP_SETTINGS, constraintType, entityNames, isEntityLevelEndpoint, isUndirected, } from './relationships.ts';

package/dist/index.js

@@ -30,6 +30,7 @@ export { parse, Parser, ParseError, SUPPORTED_XDBML_VERSION, compareVersions } f
 export { flatten } from "./module-resolver.js";
 export { classifyModuleSource, isUrlKey, ModuleSourceError, } from "./module-resolver.js";
 export { resolveNames, SymbolTable } from "./name-resolver.js";
+export { checkViews, viewSourceQuery } from "./views.js";
 export { bodyConstraints, checkConstraints, entityConstraints, isRelationalTarget, keyPathString, markPrimaryKeyNotNull, primaryKey, } from "./constraints.js";
 export { FOREIGN_MASTER_FLAG, checkRelationships, hasForeignMasterFlag, isForeignMaster, pathToString, refChildEndpoint, refParentEndpoint, relationshipType, versionAtLeast, CONSTRAINT_TYPES, V04_RELATIONSHIP_SETTINGS, constraintType, entityNames, isEntityLevelEndpoint, isUndirected, } from "./relationships.js";
 export { SUPERTYPE_GROUP_VALUES, canonicalSupertypeGroupValue, checkSupertypeGroups, resolveSupertypeGroups, subtypeStrategy, supertypeChains, supertypeGroupSettings, } from "./supertypes.js";

package/dist/keywords.d.ts

@@ -38,6 +38,7 @@ export declare const STRUCTURAL_TYPE_KEYWORDS: readonly ["object", "struct", "ar
 export declare const POLYMORPHISM_KEYWORDS: readonly ["union", "oneof", "anyof", "allof"];
 export declare const SCALAR_TYPES: readonly ["tinyint", "smallint", "mediumint", "int", "integer", "bigint", "int32", "int64", "float", "double", "decimal", "dec", "numeric", "real", "bit", "bool", "boolean", "char", "varchar", "varchar2", "nvarchar", "nvarchar2", "nchar", "text", "mediumtext", "longtext", "string", "ntext", "binary", "varbinary", "blob", "mediumblob", "longblob", "tinyblob", "tinytext", "json", "jsonb", "variant", "xml", "date", "time", "datetime", "datetime2", "timestamp", "timestamptz", "year", "uuid", "inet6", "money", "smallmoney", "enum"];
 export declare const BSON_TYPES: readonly ["objectid", "decimal128", "bindata", "minkey", "maxkey", "symbol", "regex", "long", "double"];
+export declare const BLOCK_KEYWORDS: readonly ["indexes", "checks", "constraints", "records"];
 export declare const TARGET_NATIVE_TYPES: readonly ["number", "binary_float", "binary_double", "clob", "nclob", "bfile", "raw", "rowid", "urowid", "xmltype", "sdo_geometry", "interval", "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", "uniqueidentifier", "datetimeoffset", "smalldatetime", "rowversion", "hierarchyid", "sql_variant", "timestamp_ntz", "timestamp_ltz", "timestamp_tz", "vector", "float64", "bignumeric", "bigdecimal", "bytes", "geometry", "geography", "ascii", "varint", "timeuuid", "uint32", "uint64", "sint32", "sint64", "fixed32", "fixed64", "sfixed32", "sfixed64", "uint8", "uint16", "int16", "float32"];
 export declare const SETTING_FLAGS: readonly ["pk", "primary", "key", "unique", "null", "not", "required", "increment", "inactive", "foreign_master"];
 export declare const SETTING_KEYS: readonly ["note", "default", "ref", "name", "color", "headercolor", "as", "check", "type", "target", "targets", "database_type", "source", "source_cardinality", "target_cardinality", "min_source", "max_source", "min_target", "max_target", "undirected", "source_role", "target_role", "source_verb", "target_verb", "constraint_type", "discriminator", "supertype", "completeness", "exclusivity", "strategy", "merge", "source_query", "materialized", "refresh_schedule", "refresh_on", "source_database", "storage_options", "pattern", "format", "minlength", "maxlength", "minimum", "maximum", "exclusiveminimum", "exclusivemaximum", "multipleof", "minitems", "maxitems", "uniqueitems", "minproperties", "maxproperties", "synonyms", "business_term", "granularity", "tags", "delete", "update", "indexes", "checks", "constraints", "replication", "location", "default_charset", "cloned_at"];

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',

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-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';
+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

@@ -43,6 +43,7 @@ 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.
  *
@@ -231,6 +232,8 @@ export function resolveNames(doc) {
     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.6";
+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;

package/dist/parser.js

@@ -32,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.6';
+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);
@@ -169,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];
@@ -209,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),
         };
     }
@@ -283,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());
@@ -443,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',
@@ -477,32 +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 === 'constraints' && this.peek(1).kind === TokenKind.LBrace) {
-                // v0.6 §10.1: a keyword only when `{` follows, so a field may keep
-                // the name `constraints`.
+            else if (this.atBlockKeyword('constraints')) {
                 body.push(this.parseConstraints());
             }
-            else if (k === 'records') {
+            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());
             }
         }
@@ -992,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) {
@@ -1216,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}`);
@@ -1249,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) {
@@ -1383,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) {
@@ -1412,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',
@@ -1430,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());
             }
         }
@@ -1480,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;
@@ -1754,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',
@@ -1869,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");
@@ -1928,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");
@@ -1967,7 +2056,10 @@ export class Parser {
         this.advance(); // constraints
         this.expect(TokenKind.LBrace, "Expected '{' after constraints");
         const entries = [];
-        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();
             if (t.kind === TokenKind.StringLiteral ||
                 t.kind === TokenKind.MultilineString ||

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.6.0",
+  "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",