@xdbml/parse 0.6.0 → 0.6.2

package/dist/constraints.d.ts

@@ -77,5 +77,14 @@ export declare function primaryKey(decl: {
 export declare function markPrimaryKeyNotNull(doc: XDbmlDocument): void;
 /** True for a target name the §11.17 rule covers. Unlisted names are not relational. */
 export declare function isRelationalTarget(name: string): boolean;
+/**
+ * Spec §5.2, rules 3 and 4: in a Project with several targets, every
+ * Container declares its own; and a Container's target is one of the
+ * Project's. Both apply to Containers written as such, only when the
+ * Project declares `targets:`. An implicit container (`Table core.users`)
+ * has no place for a target and is not checked. Before v0.6 the parser
+ * accepted both, so an earlier version draws warnings.
+ */
+export declare function checkTargets(doc: XDbmlDocument): Diagnostic[];
 export declare function checkConstraints(doc: XDbmlDocument): Diagnostic[];
 export {};

package/dist/constraints.js

@@ -329,6 +329,75 @@ function effectiveTarget(p, project) {
     const values = settingValues(own?.value ?? null).filter((x) => x !== '');
     return values[0] ?? project;
 }
+/** Aliases of §5.1, lower-cased, mapped to their canonical name. */
+const TARGET_ALIASES = {
+    postgres: 'postgresql', pg: 'postgresql',
+    mssql: 'sql server', 'microsoft sql server': 'sql server', 't-sql': 'sql server',
+    'ibm db2': 'db2', 'db2 luw': 'db2', 'db2 z/os': 'db2 for z/os',
+    'google bigquery': 'bigquery', 'amazon redshift': 'redshift', 'azure synapse': 'synapse analytics',
+    mongo: 'mongodb', 'aws documentdb': 'documentdb', cosmos: 'cosmos db', 'azure cosmos db': 'cosmos db',
+    'apache cassandra': 'cassandra', 'amazon neptune': 'neptune',
+    'apache avro': 'avro', 'apache parquet': 'parquet',
+    'protocol buffers': 'protobuf', proto: 'protobuf', swagger: 'openapi',
+};
+function canonicalTarget(name) {
+    const key = name.trim().toLowerCase();
+    return TARGET_ALIASES[key] ?? key;
+}
+/** Every target the Project declares, or undefined when it declares none. */
+function projectTargets(doc) {
+    for (const s of doc.statements) {
+        if (s.kind !== 'ProjectDeclaration')
+            continue;
+        for (const item of s.body) {
+            if (item.kind === 'Setting' && (item.name === 'targets' || item.name === 'database_type')) {
+                const values = settingValues(item.value).filter((x) => x !== '');
+                return values.length > 0 ? values : undefined;
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Spec §5.2, rules 3 and 4: in a Project with several targets, every
+ * Container declares its own; and a Container's target is one of the
+ * Project's. Both apply to Containers written as such, only when the
+ * Project declares `targets:`. An implicit container (`Table core.users`)
+ * has no place for a target and is not checked. Before v0.6 the parser
+ * accepted both, so an earlier version draws warnings.
+ */
+export function checkTargets(doc) {
+    const diagnostics = [];
+    const declared = projectTargets(doc);
+    if (!declared)
+        return diagnostics;
+    const severity = versionAtLeast(doc, '0.6') ? 'error' : 'warning';
+    const canon = new Set(declared.map(canonicalTarget));
+    for (const s of doc.statements) {
+        if (s.kind !== 'ContainerDeclaration')
+            continue;
+        const own = settingValues(s.settings.find((x) => x.name === 'target')?.value ?? null).filter((x) => x !== '');
+        if (own.length === 0 && declared.length > 1) {
+            diagnostics.push({
+                severity,
+                code: 'container-target-missing',
+                message: `Container '${s.name}' declares no target, and the Project declares several (${declared.join(', ')}). ` +
+                    `Write the target after its name: ${s.keyword} ${s.name} [target: ${declared[0]}] { ... } (spec §5.2).`,
+                span: s.span,
+            });
+        }
+        else if (own.length > 0 && !canon.has(canonicalTarget(own[0]))) {
+            diagnostics.push({
+                severity,
+                code: 'container-target-not-in-project',
+                message: `Container '${s.name}' targets ${own[0]}, which the Project's targets do not list (${declared.join(', ')}). ` +
+                    `Add it to the Project's targets, or change the Container's target (spec §5.2).`,
+                span: s.span,
+            });
+        }
+    }
+    return diagnostics;
+}
 /* -------------------------------------------------------------------------
  * Checks (§10.10, §11.17)
  * ----------------------------------------------------------------------- */
@@ -437,17 +506,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 +557,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/lexer.js

@@ -500,6 +500,20 @@ export class Lexer {
         if (this.isIdentStart(c)) {
             return this.lexIdentifier();
         }
+        if (c === '#') {
+            // DBML writes a color unquoted, `headercolor: #3498DB` (spec §3.3):
+            // `#` and three or six hex digits read as the string '#3498DB'.
+            let n = 1;
+            while (/[0-9A-Fa-f]/.test(this.peek(n)))
+                n++;
+            const digits = n - 1;
+            if ((digits === 3 || digits === 6) && !/[A-Za-z0-9_]/.test(this.peek(n))) {
+                for (let i = 0; i < n; i++)
+                    this.advance();
+                const text = this.text.slice(start.offset, this.offset);
+                return { kind: TokenKind.StringLiteral, text, value: text, start, end: this.pos() };
+            }
+        }
         throw new LexError(`Unexpected character: ${JSON.stringify(c)}`, start);
     }
     tokenize() {

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' | 'name-collision' | 'container-target-missing' | 'container-target-not-in-project' | '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,7 +42,9 @@ 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 { checkConstraints, checkTargets } from "./constraints.js";
+import { versionAtLeast } from "./relationships.js";
+import { checkViews } from "./views.js";
 /**
  * Read-only handle on the collected symbol table.
  *
@@ -231,6 +233,9 @@ export function resolveNames(doc) {
     diagnostics.push(...checkSupertypeGroups(flat));
     // Pass 5: constraints and referenced keys (spec §10.10, §11.17).
     diagnostics.push(...checkConstraints(flat));
+    diagnostics.push(...checkTargets(flat));
+    // Pass 6: view source queries (spec §14.7).
+    diagnostics.push(...checkViews(flat));
     return { diagnostics, symbols };
 }
 /* -------------------------------------------------------------------------
@@ -238,9 +243,18 @@ export function resolveNames(doc) {
  * ----------------------------------------------------------------------- */
 function collectDeclarations(doc, entries, diagnostics) {
     const seen = new Set(); // qualified-name keys to detect duplicates
+    const first = diagnostics.length;
     for (const stmt of doc.statements) {
         addTopLevelDeclaration(stmt, entries, diagnostics, seen);
     }
+    // Before v0.6 the parser accepted a collision, so a document declaring an
+    // earlier version, or none (DBML), draws a warning and stays valid.
+    if (!versionAtLeast(doc, '0.6')) {
+        for (const d of diagnostics.slice(first)) {
+            if (d.code === 'name-collision')
+                d.severity = 'warning';
+        }
+    }
 }
 function addTopLevelDeclaration(stmt, entries, diagnostics, seen) {
     switch (stmt.kind) {
@@ -310,9 +324,30 @@ function addTopLevelDeclaration(stmt, entries, diagnostics, seen) {
             return;
     }
 }
+const SHARED_NAMESPACE = new Set(['entity', 'view', 'edge', 'type', 'enum', 'tablepartial']);
+const KIND_NAMES = {
+    entity: 'an Entity', view: 'a View', edge: 'an Edge', type: 'a Type', enum: 'an Enum', tablepartial: 'a TablePartial',
+};
+function article(kind) {
+    return KIND_NAMES[kind] ?? kind;
+}
 function addEntry(name, containerName, kind, declaration, span, entries, diagnostics, seen) {
     const qualifiedName = containerName ? `${containerName}.${name}` : name;
     const key = `${kind}:${qualifiedName}`;
+    // Spec §15.5: Entities, Views, Edges, Types, Enums and TablePartials
+    // share one namespace. collectDeclarations() sets the severity.
+    if (SHARED_NAMESPACE.has(kind) && !seen.has(key)) {
+        const other = entries.find((e) => e.qualifiedName === qualifiedName && e.kind !== kind && SHARED_NAMESPACE.has(e.kind));
+        if (other) {
+            diagnostics.push({
+                severity: 'error',
+                code: 'name-collision',
+                message: `'${qualifiedName}' names both ${article(other.kind)} and ${article(kind)}. ` +
+                    `Entities, Views, Edges, Types, Enums and TablePartials share one namespace (spec §15.5): rename one of them.`,
+                span,
+            });
+        }
+    }
     if (seen.has(key)) {
         diagnostics.push({
             severity: 'error',

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.2";
 /** 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.2';
 /** 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) {
@@ -1318,6 +1385,17 @@ export class Parser {
             }
             this.expect(TokenKind.RParen, "Expected ')' closing type parameters");
         }
+        // DBML's array type of a target, `text[]` or `varchar(20)[]`, keeps its
+        // brackets in the type name (spec §8.1). Only empty brackets written
+        // right after the type, with no space, belong to it: `int [pk]` and
+        // `int []` remain settings blocks.
+        while (this.check(TokenKind.LBracket) &&
+            this.peek(1).kind === TokenKind.RBracket &&
+            this.peek().start.offset === this.tokens[this.idx - 1].end.offset) {
+            this.advance();
+            this.advance();
+            name += '[]';
+        }
         return {
             kind: 'ScalarType',
             name,
@@ -1383,10 +1461,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 +1492,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 +1510,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 +1566,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 +1843,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 +1958,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 +2025,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 +2067,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 ||
@@ -2284,7 +2387,66 @@ export function parse(source, options = {}) {
     const initialStack = new Set();
     if (options.filePath)
         initialStack.add(options.filePath);
-    return new Parser(tokens, options, initialStack, 0).parseDocument();
+    const doc = new Parser(tokens, options, initialStack, 0).parseDocument();
+    applyEntityAliases(doc);
+    return doc;
+}
+/**
+ * Spec §7.4: `Table very_long_name as V { ... }` lets a relationship name
+ * the entity by its alias, `Ref: V.id < posts.user_id`, as in DBML. This
+ * pass rewrites the first segment of every relationship endpoint that is
+ * an alias into the entity's name, so the resolver, the key checks and the
+ * renderer see the entity itself. The entity keeps its `alias`. An alias
+ * that repeats the name of an entity or a container, or that two entities
+ * declare, is left alone: the name it would shadow applies.
+ */
+function applyEntityAliases(doc) {
+    const aliases = new Map();
+    const taken = new Set();
+    const visit = (decl, container) => {
+        if (decl.kind !== 'EntityDeclaration')
+            return;
+        const segments = [...(container ? [container] : []), ...decl.name.split('.')];
+        taken.add(segments[segments.length - 1]);
+        if (!decl.alias)
+            return;
+        aliases.set(decl.alias, aliases.has(decl.alias) ? null : segments);
+    };
+    for (const stmt of doc.statements) {
+        if (stmt.kind === 'ContainerDeclaration') {
+            taken.add(stmt.name);
+            for (const body of stmt.body)
+                visit(body, stmt.name);
+        }
+        else {
+            visit(stmt);
+        }
+    }
+    for (const name of taken)
+        aliases.delete(name);
+    if (![...aliases.values()].some((v) => v !== null))
+        return;
+    const walk = (node) => {
+        if (Array.isArray(node)) {
+            node.forEach(walk);
+            return;
+        }
+        if (!node || typeof node !== 'object')
+            return;
+        const obj = node;
+        if (obj.kind === 'RefEndpoint' && Array.isArray(obj.path)) {
+            const first = obj.path[0];
+            const segments = first?.kind === 'PathField' && first.name ? aliases.get(first.name) : undefined;
+            if (segments) {
+                obj.path = [...segments.map((name) => ({ ...first, name })), ...obj.path.slice(1)];
+            }
+        }
+        for (const [key, value] of Object.entries(obj)) {
+            if (key !== 'span' && value && typeof value === 'object')
+                walk(value);
+        }
+    };
+    walk(doc.statements);
 }
 /**
  * Internal `ParseFn` used by the module resolver to recursively parse a

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.2",
   "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",