@xdbml/parse 0.6.1 → 0.6.3

package/README.md

@@ -48,6 +48,15 @@ try {
 
 The package also exports `tokenize`, `LexError`, `Parser`, `SymbolTable`, and the AST types.
 
+For diagram views (spec §18), `diagramViews(doc)` lists the `DiagramView` declarations, and `diagramViewMembers(doc, name)` returns the entities, database views and sticky notes a diagram view contains, with the Containers, TableGroups and supertype groups a renderer frames or draws around them.
+
+```ts
+import { parse, diagramViewMembers } from '@xdbml/parse';
+
+const members = diagramViewMembers(parse(source), 'order_flow');
+console.log(members?.entities); // ['sales.orders', 'billing.invoices', ...]
+```
+
 ## Learn more
 
 - [xdbml.org](https://xdbml.org), and the language [in 5 minutes](https://xdbml.org/learn/)

package/dist/ast.d.ts

@@ -38,7 +38,7 @@ export interface ExperimentalDeclaration {
     features: string[];
     span: Span;
 }
-export type TopLevelStatement = ProjectDeclaration | ContainerDeclaration | EntityDeclaration | TypeDeclaration | EdgeDeclaration | ViewDeclaration | EnumDeclaration | RefDeclaration | TablePartialDeclaration | TableGroupDeclaration | SupertypeGroupDeclaration | NoteDeclaration | TopLevelRecordsDeclaration | ModuleImportDirective;
+export type TopLevelStatement = ProjectDeclaration | ContainerDeclaration | EntityDeclaration | TypeDeclaration | EdgeDeclaration | ViewDeclaration | EnumDeclaration | RefDeclaration | TablePartialDeclaration | TableGroupDeclaration | SupertypeGroupDeclaration | DiagramViewDeclaration | NoteDeclaration | TopLevelRecordsDeclaration | ModuleImportDirective;
 export interface ProjectDeclaration {
     kind: 'ProjectDeclaration';
     name: string;
@@ -385,6 +385,36 @@ export interface SupertypeGroupMember {
     settings: Setting[];
     span: Span;
 }
+export type DiagramViewCategoryName = 'Tables' | 'Views' | 'Containers' | 'TableGroups' | 'SupertypeGroups' | 'Notes';
+export interface DiagramViewDeclaration {
+    kind: 'DiagramViewDeclaration';
+    name: string;
+    /** Bracket settings: `note` and custom `x_` properties (spec §18.1). */
+    settings: Setting[];
+    /** `Note:` / `Note { }` elements of the body. `diagramViewNote()` gives the note. */
+    notes: NoteBlock[];
+    /** True when the whole body is `{ * }`: every element of every category. */
+    wildcardBody: boolean;
+    categories: DiagramViewCategory[];
+    span: Span;
+}
+export interface DiagramViewCategory {
+    kind: 'DiagramViewCategory';
+    /** Canonical category: `Schemas` reads as `Containers`. */
+    category: DiagramViewCategoryName;
+    /** The keyword as written, for round trips and the DBML-form check of §18.5. */
+    keyword: string;
+    /** True when the list holds `*`; names written beside it have no effect. */
+    wildcard: boolean;
+    items: DiagramViewItem[];
+    span: Span;
+}
+export interface DiagramViewItem {
+    kind: 'DiagramViewItem';
+    /** Name as written: `orders` or `sales.orders`. */
+    name: string;
+    span: Span;
+}
 export interface PartialInjection {
     kind: 'PartialInjection';
     /** Identifier after the `~`. */

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)
  * ----------------------------------------------------------------------- */

package/dist/diagram-views.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Diagram views (spec §18, defined in v0.6.3).
+ *
+ * A diagram view is a named subset of the model's diagram. Its body lists
+ * categories of elements; `diagramViewMembers()` turns those lists into the
+ * members of §18.2, and `checkDiagramViews()` reports the conditions of
+ * §18.6. Both take a document and flatten it, so elements imported from
+ * other files count like the ones declared in place (§18.3).
+ *
+ * Element ids follow the renderer and the supertype group resolver: an
+ * entity or database view inside a Container is `container.name`, one at
+ * the top level is its name as declared, which for the DBML form
+ * `Table core.users` is `core.users` in the implicit Container `core`.
+ */
+import type { DiagramViewDeclaration, XDbmlDocument } from './ast.ts';
+import type { Diagnostic } from './name-resolver.ts';
+/** The members of a diagram view (spec §18.2) and what a renderer draws with them (§18.4). */
+export interface DiagramViewMembers {
+    /** The diagram view these members belong to. */
+    declaration: DiagramViewDeclaration;
+    /** Ids of the member entities, in declaration order. */
+    entities: string[];
+    /** Ids of the member database views, in declaration order. */
+    views: string[];
+    /** Names of the member sticky notes, in declaration order. */
+    notes: string[];
+    /** Containers holding at least one member: their frames surround those members only. */
+    containers: string[];
+    /** TableGroups with at least one member entity, named in the diagram view or not. */
+    tableGroups: string[];
+    /** Supertype groups whose supertype and at least one subtype are members (§12.9). */
+    supertypeGroups: string[];
+}
+/**
+ * The note of a diagram view (spec §18.1): its first `Note` in the body,
+ * otherwise the `note` setting in its brackets, otherwise undefined.
+ */
+export declare function diagramViewNote(view: DiagramViewDeclaration): string | undefined;
+/** Every DiagramView of a document, in declaration order, after module resolution. */
+export declare function diagramViews(doc: XDbmlDocument): DiagramViewDeclaration[];
+/**
+ * The members of the diagram view named `name`, or undefined when the
+ * document declares none of that name. With two of one name (an error),
+ * the first one counts.
+ */
+export declare function diagramViewMembers(doc: XDbmlDocument, name: string): DiagramViewMembers | undefined;
+/** The conditions of spec §18.6 that a parse leaves to name resolution. */
+export declare function checkDiagramViews(doc: XDbmlDocument): Diagnostic[];

package/dist/diagram-views.js

@@ -0,0 +1,411 @@
+/**
+ * Diagram views (spec §18, defined in v0.6.3).
+ *
+ * A diagram view is a named subset of the model's diagram. Its body lists
+ * categories of elements; `diagramViewMembers()` turns those lists into the
+ * members of §18.2, and `checkDiagramViews()` reports the conditions of
+ * §18.6. Both take a document and flatten it, so elements imported from
+ * other files count like the ones declared in place (§18.3).
+ *
+ * Element ids follow the renderer and the supertype group resolver: an
+ * entity or database view inside a Container is `container.name`, one at
+ * the top level is its name as declared, which for the DBML form
+ * `Table core.users` is `core.users` in the implicit Container `core`.
+ */
+import { flatten } from "./module-resolver.js";
+import { resolveSupertypeGroups } from "./supertypes.js";
+/**
+ * The note of a diagram view (spec §18.1): its first `Note` in the body,
+ * otherwise the `note` setting in its brackets, otherwise undefined.
+ */
+export function diagramViewNote(view) {
+    if (view.notes.length > 0)
+        return view.notes[0].body;
+    const s = view.settings.find((x) => x.name === 'note');
+    const v = s?.value;
+    return v && v.kind === 'StringValue' ? v.value : undefined;
+}
+/** Every DiagramView of a document, in declaration order, after module resolution. */
+export function diagramViews(doc) {
+    return flatten(doc).statements.filter((s) => s.kind === 'DiagramViewDeclaration');
+}
+/**
+ * The members of the diagram view named `name`, or undefined when the
+ * document declares none of that name. With two of one name (an error),
+ * the first one counts.
+ */
+export function diagramViewMembers(doc, name) {
+    const flat = flatten(doc);
+    const decl = flat.statements.find((s) => s.kind === 'DiagramViewDeclaration' && s.name === name);
+    if (!decl)
+        return undefined;
+    return computeMembers(decl, buildIndex(flat), flat);
+}
+const key = (kind, id) => `${kind}:${id}`;
+function buildIndex(doc) {
+    const elements = [];
+    const byKindId = new Map();
+    const entitiesOf = new Map();
+    const viewsOf = new Map();
+    const tableGroupMembers = new Map();
+    const aliasCandidates = new Map();
+    const takenNames = new Set();
+    const add = (kind, id, name, container, topLevel) => {
+        if (byKindId.has(key(kind, id)))
+            return;
+        const el = { kind, id, name, container, topLevel };
+        elements.push(el);
+        byKindId.set(key(kind, id), el);
+        if (container && (kind === 'entity' || kind === 'view')) {
+            const map = kind === 'entity' ? entitiesOf : viewsOf;
+            const list = map.get(container) ?? [];
+            list.push(id);
+            map.set(container, list);
+            if (!byKindId.has(key('container', container))) {
+                add('container', container, container, undefined, true);
+            }
+        }
+    };
+    const addBoxed = (kind, decl, container) => {
+        let id;
+        let bare;
+        let owner = container;
+        if (container) {
+            id = `${container}.${decl.name}`;
+            bare = decl.name;
+        }
+        else {
+            id = decl.name;
+            const dot = decl.name.lastIndexOf('.');
+            bare = dot > 0 ? decl.name.slice(dot + 1) : decl.name;
+            owner = dot > 0 ? decl.name.slice(0, dot) : undefined;
+        }
+        add(kind, id, bare, owner, owner === undefined);
+        takenNames.add(bare);
+        if (kind === 'entity') {
+            const alias = decl.alias;
+            if (alias)
+                aliasCandidates.set(alias, aliasCandidates.has(alias) ? null : id);
+        }
+    };
+    for (const stmt of doc.statements) {
+        switch (stmt.kind) {
+            case 'ContainerDeclaration': {
+                const c = stmt;
+                add('container', c.name, c.name, undefined, true);
+                takenNames.add(c.name);
+                for (const item of c.body) {
+                    if (item.kind === 'EntityDeclaration')
+                        addBoxed('entity', item, c.name);
+                    else if (item.kind === 'ViewDeclaration')
+                        addBoxed('view', item, c.name);
+                    else if (item.kind === 'EdgeDeclaration')
+                        add('edge', `${c.name}.${item.name}`, item.name, c.name, false);
+                }
+                break;
+            }
+            case 'EntityDeclaration':
+                addBoxed('entity', stmt);
+                break;
+            case 'ViewDeclaration':
+                addBoxed('view', stmt);
+                break;
+            case 'EdgeDeclaration':
+                add('edge', stmt.name, stmt.name, undefined, true);
+                break;
+            case 'TableGroupDeclaration':
+                add('tablegroup', stmt.name, stmt.name, undefined, true);
+                if (!tableGroupMembers.has(stmt.name))
+                    tableGroupMembers.set(stmt.name, stmt.members);
+                break;
+            case 'SupertypeGroupDeclaration':
+                add('supertypegroup', stmt.name, stmt.name, undefined, true);
+                break;
+            case 'NoteDeclaration':
+                if (stmt.name)
+                    add('note', stmt.name, stmt.name, undefined, true);
+                break;
+            default: break;
+        }
+    }
+    // An alias that repeats the name of an entity or a Container, or that two
+    // entities declare, names nothing (§7.4).
+    const aliases = new Map();
+    for (const [alias, id] of aliasCandidates) {
+        if (id !== null && !takenNames.has(alias))
+            aliases.set(alias, id);
+    }
+    return { elements, byKindId, entitiesOf, viewsOf, aliases, tableGroupMembers };
+}
+/* --------------------------------------------------------- resolution */
+const CATEGORY_KIND = {
+    Tables: 'entity',
+    Views: 'view',
+    Containers: 'container',
+    TableGroups: 'tablegroup',
+    SupertypeGroups: 'supertypegroup',
+    Notes: 'note',
+};
+const KIND_CATEGORY = {
+    entity: 'Tables',
+    view: 'Views',
+    container: 'Containers',
+    tablegroup: 'TableGroups',
+    supertypegroup: 'SupertypeGroups',
+    note: 'Notes',
+};
+const KIND_LABEL = {
+    entity: 'an entity',
+    view: 'a database view',
+    container: 'a Container',
+    tablegroup: 'a TableGroup',
+    supertypegroup: 'a supertype group',
+    note: 'a sticky note',
+    edge: 'an Edge',
+};
+/**
+ * Resolve a name of one kind (spec §18.3). A qualified name names the
+ * element with that id. An unqualified name names the element declared
+ * outside any Container under that name, if any, and otherwise the one
+ * element of that name inside a Container. Under Tables, an alias names
+ * its entity.
+ */
+function resolveName(name, kind, index) {
+    const direct = index.byKindId.get(key(kind, name));
+    if (direct)
+        return { ok: true, id: direct.id };
+    if (!name.includes('.') && (kind === 'entity' || kind === 'view')) {
+        const top = index.elements.find((e) => e.kind === kind && e.topLevel && e.name === name);
+        if (top)
+            return { ok: true, id: top.id };
+        const inside = index.elements.filter((e) => e.kind === kind && e.name === name);
+        if (inside.length === 1)
+            return { ok: true, id: inside[0].id };
+        if (inside.length > 1)
+            return { ok: false, reason: 'ambiguous', candidates: inside.map((e) => e.id) };
+    }
+    if (kind === 'entity') {
+        const aliased = index.aliases.get(name);
+        if (aliased)
+            return { ok: true, id: aliased };
+    }
+    for (const other of ['entity', 'view', 'container', 'tablegroup', 'supertypegroup', 'note', 'edge']) {
+        if (other === kind)
+            continue;
+        if (resolveSimple(name, other, index))
+            return { ok: false, reason: 'other-kind', kind: other };
+    }
+    return { ok: false, reason: 'unresolved' };
+}
+function resolveSimple(name, kind, index) {
+    if (index.byKindId.has(key(kind, name)))
+        return true;
+    if (!name.includes('.'))
+        return index.elements.some((e) => e.kind === kind && e.name === name);
+    return false;
+}
+/** The categories of a diagram view, with a body-level `*` read as `*` in every category (§28.8). */
+function effectiveCategories(decl) {
+    const out = new Map();
+    if (decl.wildcardBody) {
+        for (const name of Object.keys(CATEGORY_KIND)) {
+            out.set(name, { wildcard: true, items: [] });
+        }
+        return out;
+    }
+    // A category written twice is reported by checkDiagramViews(); its lists combine.
+    for (const c of decl.categories) {
+        const prev = out.get(c.category);
+        out.set(c.category, {
+            wildcard: (prev?.wildcard ?? false) || c.wildcard,
+            items: [...(prev?.items ?? []), ...c.items],
+        });
+    }
+    return out;
+}
+function computeMembers(decl, index, doc) {
+    const cats = effectiveCategories(decl);
+    const all = (kind) => index.elements.filter((e) => e.kind === kind).map((e) => e.id);
+    const named = (category) => {
+        const c = cats.get(category);
+        if (!c)
+            return new Set();
+        if (c.wildcard)
+            return new Set(all(CATEGORY_KIND[category]));
+        const ids = new Set();
+        for (const item of c.items) {
+            const r = resolveName(item.name, CATEGORY_KIND[category], index);
+            if (r.ok)
+                ids.add(r.id);
+        }
+        return ids;
+    };
+    const entities = named('Tables');
+    const views = named('Views');
+    // Rule 2: a listed Container contributes its entities and its database
+    // views, each list narrowed separately to the names under Tables or Views
+    // when they name at least one of the Container's own.
+    for (const container of named('Containers')) {
+        const ownEntities = index.entitiesOf.get(container) ?? [];
+        if (!ownEntities.some((id) => entities.has(id)))
+            ownEntities.forEach((id) => entities.add(id));
+        const ownViews = index.viewsOf.get(container) ?? [];
+        if (!ownViews.some((id) => views.has(id)))
+            ownViews.forEach((id) => views.add(id));
+    }
+    // Rule 3: each named TableGroup contributes all of its members.
+    for (const group of named('TableGroups')) {
+        for (const member of index.tableGroupMembers.get(group) ?? []) {
+            const r = resolveName(member, 'entity', index);
+            if (r.ok)
+                entities.add(r.id);
+        }
+    }
+    // Rule 4: each named supertype group contributes its supertype and subtypes.
+    const groups = resolveSupertypeGroups(doc);
+    const namedGroups = named('SupertypeGroups');
+    for (const g of groups) {
+        if (!namedGroups.has(g.declaration.name))
+            continue;
+        if (g.supertype)
+            entities.add(g.supertype);
+        for (const s of g.subtypes)
+            if (s.entity)
+                entities.add(s.entity);
+    }
+    const notes = named('Notes');
+    const ordered = (kind, set) => all(kind).filter((id) => set.has(id));
+    const memberEntities = ordered('entity', entities);
+    const memberViews = ordered('view', views);
+    const boxed = new Set([...memberEntities, ...memberViews]);
+    const containers = all('container').filter((c) => [...(index.entitiesOf.get(c) ?? []), ...(index.viewsOf.get(c) ?? [])].some((id) => boxed.has(id)));
+    const tableGroups = all('tablegroup').filter((g) => (index.tableGroupMembers.get(g) ?? []).some((m) => {
+        const r = resolveName(m, 'entity', index);
+        return r.ok && entities.has(r.id);
+    }));
+    const supertypeGroups = groups
+        .filter((g) => g.supertype && entities.has(g.supertype) && g.subtypes.some((s) => s.entity && entities.has(s.entity)))
+        .map((g) => g.declaration.name);
+    return {
+        declaration: decl,
+        entities: memberEntities,
+        views: memberViews,
+        notes: ordered('note', notes),
+        containers,
+        tableGroups,
+        supertypeGroups: [...new Set(supertypeGroups)],
+    };
+}
+/* --------------------------------------------------------- diagnostics */
+/** The conditions of spec §18.6 that a parse leaves to name resolution. */
+export function checkDiagramViews(doc) {
+    const views = doc.statements.filter((s) => s.kind === 'DiagramViewDeclaration');
+    if (views.length === 0)
+        return [];
+    const index = buildIndex(doc);
+    const diagnostics = [];
+    const declared = !!doc.version;
+    const seen = new Set();
+    for (const view of views) {
+        if (seen.has(view.name)) {
+            diagnostics.push({
+                severity: 'error',
+                code: 'duplicate-diagram-view',
+                message: `A diagram view named '${view.name}' is already declared. Diagram view names are unique (spec §18.1).`,
+                span: view.span,
+            });
+        }
+        seen.add(view.name);
+        // §18.1: the brackets take `note` and custom properties only.
+        for (const setting of view.settings) {
+            if (setting.name === 'note' || setting.name.startsWith('x_'))
+                continue;
+            diagnostics.push({
+                severity: 'error',
+                code: 'unknown-diagram-view-setting',
+                message: `Diagram view '${view.name}' writes the setting '${setting.nameSource}'. A diagram view takes ` +
+                    'a note and custom x_ properties in its brackets, and no other setting (spec §18.1).',
+                span: setting.span,
+            });
+        }
+        // §18.5: a note and the brackets are xDBML extensions.
+        if (!declared && (view.settings.length > 0 || view.notes.length > 0)) {
+            diagnostics.push({
+                severity: 'error',
+                code: 'construct-requires-version',
+                message: `Diagram view '${view.name}' carries a note or settings, an xDBML extension that needs a ` +
+                    'version declaration such as xdbml: 0.6 at the top of the document (spec §18.5).',
+                span: (view.settings[0] ?? view.notes[0]).span,
+            });
+        }
+        const written = new Map();
+        for (const c of view.categories) {
+            const first = written.get(c.category);
+            if (first) {
+                const same = first.keyword.toLowerCase() === c.keyword.toLowerCase();
+                diagnostics.push({
+                    severity: declared ? 'error' : 'warning',
+                    code: 'duplicate-diagram-view-category',
+                    message: same
+                        ? `Diagram view '${view.name}' writes ${c.keyword} twice. Write each category once (spec §18.1).`
+                        : `Diagram view '${view.name}' writes both ${first.keyword} and ${c.keyword}, which are one ` +
+                            'category: Schemas is the DBML name of Containers (spec §18.1).',
+                    span: c.span,
+                });
+            }
+            else {
+                written.set(c.category, c);
+            }
+            // §18.5: Containers, Views and SupertypeGroups are xDBML extensions.
+            if (!declared && c.keyword.toLowerCase() !== 'schemas'
+                && (c.category === 'Containers' || c.category === 'Views' || c.category === 'SupertypeGroups')) {
+                diagnostics.push({
+                    severity: 'error',
+                    code: 'construct-requires-version',
+                    message: `The ${c.keyword} category of a diagram view is an xDBML extension and needs a version ` +
+                        'declaration such as xdbml: 0.6 at the top of the document' +
+                        (c.category === 'Containers' ? ', or the DBML name Schemas' : '') + ' (spec §18.5).',
+                    span: c.span,
+                });
+            }
+            if (c.wildcard)
+                continue;
+            for (const item of c.items) {
+                const r = resolveName(item.name, CATEGORY_KIND[c.category], index);
+                if (r.ok)
+                    continue;
+                if (r.reason === 'ambiguous') {
+                    diagnostics.push({
+                        severity: 'error',
+                        code: 'ambiguous-diagram-view-name',
+                        message: `'${item.name}' under ${c.keyword} matches ${r.candidates.map((x) => `'${x}'`).join(' and ')}, ` +
+                            'and none is declared outside a Container: write the qualified name (spec §18.3).',
+                        span: item.span,
+                    });
+                }
+                else if (r.reason === 'other-kind') {
+                    const right = KIND_CATEGORY[r.kind];
+                    diagnostics.push({
+                        severity: 'error',
+                        code: 'diagram-view-wrong-category',
+                        message: `'${item.name}' under ${c.keyword} is ${KIND_LABEL[r.kind]}` +
+                            (right
+                                ? `: list it under ${right} (spec §18.3).`
+                                : ', which appears in a diagram view when both of its ends do and is never listed (spec §18.1, §18.4).'),
+                        span: item.span,
+                    });
+                }
+                else {
+                    diagnostics.push({
+                        severity: 'error',
+                        code: 'unresolved-diagram-view-name',
+                        message: `'${item.name}' under ${c.keyword} matches no ${KIND_LABEL[CATEGORY_KIND[c.category]].replace(/^an? /, '')} ` +
+                            'in the project (spec §18.3).',
+                        span: item.span,
+                    });
+                }
+            }
+        }
+    }
+    return diagnostics;
+}

package/dist/index.d.ts

@@ -33,6 +33,8 @@ export { classifyModuleSource, isUrlKey, ModuleSourceError, } from './module-res
 export type { ModuleSource } from './module-resolver.ts';
 export { resolveNames, SymbolTable } from './name-resolver.ts';
 export { checkViews, viewSourceQuery } from './views.ts';
+export { checkDiagramViews, diagramViewMembers, diagramViewNote, diagramViews } from './diagram-views.ts';
+export type { DiagramViewMembers } from './diagram-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

@@ -31,6 +31,7 @@ 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 { checkDiagramViews, diagramViewMembers, diagramViewNote, diagramViews } from "./diagram-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

@@ -39,6 +39,7 @@ export declare const POLYMORPHISM_KEYWORDS: readonly ["union", "oneof", "anyof",
 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 DIAGRAM_VIEW_CATEGORIES: readonly ["tables", "views", "containers", "schemas", "tablegroups", "supertypegroups", "notes"];
 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

@@ -170,6 +170,22 @@ export const BSON_TYPES = [
  * and only when `{` follows, since a field may carry one of these names.
  * ----------------------------------------------------------------------- */
 export const BLOCK_KEYWORDS = ['indexes', 'checks', 'constraints', 'records'];
+/* -------------------------------------------------------------------------
+ * DiagramView categories (spec §18.1, v0.6.3)
+ *
+ * The words that open a category inside a DiagramView body. `schemas` is
+ * the DBML name of `containers`. Both highlighters color them only when `{`
+ * follows, since an entity or a field may carry one of these names.
+ * ----------------------------------------------------------------------- */
+export const DIAGRAM_VIEW_CATEGORIES = [
+    'tables',
+    'views',
+    'containers',
+    'schemas',
+    'tablegroups',
+    'supertypegroups',
+    'notes',
+];
 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/module-resolver.js

@@ -78,7 +78,18 @@ function flattenTopLevel(stmt, out) {
         return;
     }
     if (stmt.kind === 'ContainerDeclaration') {
-        out.push(flattenContainer(stmt));
+        // A `reuse *` inside a Container body can clone a DiagramView into it.
+        // A DiagramView is top-level only (spec §18.1), so it moves out to the
+        // top level, after its Container.
+        const flat = flattenContainer(stmt);
+        const hoisted = flat.body.filter((b) => b.kind === 'DiagramViewDeclaration');
+        if (hoisted.length === 0) {
+            out.push(flat);
+            return;
+        }
+        out.push({ ...flat, body: flat.body.filter((b) => !hoisted.includes(b)) });
+        for (const view of hoisted)
+            out.push(view);
         return;
     }
     // All other top-level statement kinds pass through unchanged.
@@ -376,8 +387,13 @@ function findImportTarget(item, doc) {
         }
         return undefined;
     }
-    // View / DiagramView: top-level OR container-scoped.
-    if (item.elementType === 'view' || item.elementType === 'diagramview') {
+    // DiagramView (spec §18): top-level only, bare name. Its names resolve
+    // in the importing document, like the members of a TableGroup.
+    if (item.elementType === 'diagramview') {
+        return doc.statements.find((s) => s.kind === 'DiagramViewDeclaration' && s.name === path);
+    }
+    // View: top-level OR container-scoped.
+    if (item.elementType === 'view') {
         if (segments.length === 1) {
             return doc.statements.find((s) => s.kind === 'ViewDeclaration' && s.name === segments[0]);
         }
@@ -614,6 +630,8 @@ function applyAlias(stmt, item) {
             return { ...stmt, name: item.alias };
         case 'SupertypeGroupDeclaration':
             return { ...stmt, name: item.alias };
+        case 'DiagramViewDeclaration':
+            return { ...stmt, name: item.alias };
         case 'TablePartialDeclaration':
             return { ...stmt, name: item.alias };
         case 'NoteDeclaration':

package/dist/monarch.js

@@ -18,7 +18,7 @@
  * dependency on consumers that just want to parse. The Monaco types
  * are structurally compatible -- the consumer casts at the boundary.
  */
-import { CONTAINER_KEYWORDS, ENTITY_KEYWORDS, DECLARATION_KEYWORDS, STRUCTURAL_TYPE_KEYWORDS, POLYMORPHISM_KEYWORDS, SCALAR_TYPES, BSON_TYPES, TARGET_NATIVE_TYPES, SETTING_FLAGS, SETTING_KEYS, GRANULARITY_VALUES, } from "./keywords.js";
+import { CONTAINER_KEYWORDS, ENTITY_KEYWORDS, DECLARATION_KEYWORDS, STRUCTURAL_TYPE_KEYWORDS, POLYMORPHISM_KEYWORDS, SCALAR_TYPES, BSON_TYPES, TARGET_NATIVE_TYPES, SETTING_FLAGS, SETTING_KEYS, GRANULARITY_VALUES, DIAGRAM_VIEW_CATEGORIES, } from "./keywords.js";
 /* -------------------------------------------------------------------------
  * Language configuration
  * ----------------------------------------------------------------------- */
@@ -160,6 +160,9 @@ export const xdbmlMonarchTokensProvider = {
             // 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'],
+            // Spec §18.1 (v0.6.3): a DiagramView category keyword opens its list
+            // only before '{'. Elsewhere the same word names an entity or a field.
+            [new RegExp(`(?:${DIAGRAM_VIEW_CATEGORIES.join('|')})(?![\\w$])(?=\\s*\\{)`), 'keyword.declaration'],
             // 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' | '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';
+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' | 'duplicate-diagram-view' | 'duplicate-diagram-view-category' | 'unresolved-diagram-view-name' | 'ambiguous-diagram-view-name' | 'diagram-view-wrong-category' | 'unknown-diagram-view-setting';
 /**
  * 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,8 +42,10 @@ 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";
+import { checkDiagramViews } from "./diagram-views.js";
 /**
  * Read-only handle on the collected symbol table.
  *
@@ -232,8 +234,11 @@ 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));
+    // Pass 7: diagram views (spec §18.6).
+    diagnostics.push(...checkDiagramViews(flat));
     return { diagnostics, symbols };
 }
 /* -------------------------------------------------------------------------
@@ -241,9 +246,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) {
@@ -313,9 +327,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.1";
+export declare const SUPPORTED_XDBML_VERSION = "0.6.3";
 /** Compare dotted version strings numerically: -1, 0 or 1. */
 export declare function compareVersions(a: string, b: string): number;
 export declare class Parser {
@@ -345,6 +345,21 @@ export declare class Parser {
      * rather than stopping the parse.
      */
     private parseSupertypeGroup;
+    /**
+     * `DiagramView <name> { <Category> { <names> | * } ... }`, or
+     * `DiagramView <name> { * }` for every element of every category.
+     * Category keywords are case-insensitive; `Schemas` reads as `Containers`.
+     * Lists follow spec §3.9: whitespace between names, with commas and
+     * semicolons allowed and meaningless. Names stay unresolved here; the
+     * checks of §18.6 run after parsing, in `checkDiagramViews()`, so a bad
+     * name gets a located diagnostic and the rest of the diagram still draws.
+     * Two conditions stop the parse because they leave no category to read:
+     * an unknown category, `Edges` included, and a body-level `*` with a
+     * category beside it. A note may sit in the brackets or in the body
+     * (spec §18.1, v0.6.3).
+     */
+    private parseDiagramView;
+    private parseDiagramViewCategory;
     private parseIndexes;
     private parseIndexEntry;
     private parseIndexComponent;

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.1';
+export const SUPPORTED_XDBML_VERSION = '0.6.3';
 /** Compare dotted version strings numerically: -1, 0 or 1. */
 export function compareVersions(a, b) {
     const pa = a.split('.').map((n) => Number(n) || 0);
@@ -74,6 +74,19 @@ const IMPORT_ELEMENT_TYPES = new Set([
     'type', 'edge', 'view', 'diagramview',
     'field', 'supertypegroup',
 ]);
+/**
+ * DiagramView categories (spec §18.1), by lowercased keyword. `Schemas`, the
+ * DBML name, reads as `Containers`, after the `Schema` keyword (§6.2).
+ */
+const DIAGRAM_VIEW_CATEGORIES = {
+    tables: 'Tables',
+    views: 'Views',
+    containers: 'Containers',
+    schemas: 'Containers',
+    tablegroups: 'TableGroups',
+    supertypegroups: 'SupertypeGroups',
+    notes: 'Notes',
+};
 const STRUCTURAL_TYPE_KEYWORDS = new Set([
     'object', 'struct', 'record', 'array', 'list', 'map', 'dict', 'dictionary',
     'set', 'union', 'oneof', 'anyof', 'allof', 'json', 'jsonb', 'variant',
@@ -320,6 +333,8 @@ export class Parser {
             return this.parseTableGroup();
         if (k === 'supertypegroup')
             return this.parseSupertypeGroup();
+        if (k === 'diagramview')
+            return this.parseDiagramView();
         if (k === 'note')
             return this.parseNoteDeclaration();
         if (k === 'records')
@@ -471,6 +486,10 @@ export class Parser {
             else if (k === 'use' || k === 'reuse') {
                 body.push(this.parseModuleDirective('container-body'));
             }
+            else if (k === 'diagramview') {
+                throw new ParseError(`A DiagramView is a top-level declaration and never appears in a Container (spec §18.1). ` +
+                    `Move it out of Container '${name}'.`, t.start);
+            }
             else {
                 // Unknown line; tolerate as no-op rather than fail the whole parse.
                 throw new ParseError(`Unexpected token in Container body: ${t.kind} ${JSON.stringify(t.text)}`, t.start);
@@ -860,6 +879,11 @@ export class Parser {
             throw new ParseError(`Unknown import element type '${elemTok.text}'. ` +
                 `Expected one of: ${Array.from(IMPORT_ELEMENT_TYPES).join(', ')}.`, elemTok.start);
         }
+        if (elementType === 'diagramview' && context !== 'file-scope') {
+            // Spec §18.1, §27.5: a DiagramView is a top-level declaration, so its
+            // import goes at file scope, where the declaration itself would.
+            throw new ParseError('A DiagramView is a top-level declaration: import it at file scope, not inside a Container body (spec §18.1, §27.5).', elemTok.start);
+        }
         if (elementType === 'field' && context !== 'file-scope') {
             // Spec §27.8: field imports must appear at file scope. Inside a
             // Container body, the field's eventual placement (as a Named Type)
@@ -1385,6 +1409,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,
@@ -1940,6 +1975,120 @@ export class Parser {
             span: this.spanFrom(start),
         };
     }
+    /* ----- DiagramView (spec §18, defined in v0.6.3) ----- */
+    /**
+     * `DiagramView <name> { <Category> { <names> | * } ... }`, or
+     * `DiagramView <name> { * }` for every element of every category.
+     * Category keywords are case-insensitive; `Schemas` reads as `Containers`.
+     * Lists follow spec §3.9: whitespace between names, with commas and
+     * semicolons allowed and meaningless. Names stay unresolved here; the
+     * checks of §18.6 run after parsing, in `checkDiagramViews()`, so a bad
+     * name gets a located diagnostic and the rest of the diagram still draws.
+     * Two conditions stop the parse because they leave no category to read:
+     * an unknown category, `Edges` included, and a body-level `*` with a
+     * category beside it. A note may sit in the brackets or in the body
+     * (spec §18.1, v0.6.3).
+     */
+    parseDiagramView() {
+        const start = this.peek().start;
+        this.advance(); // DiagramView
+        const nameTok = this.peek();
+        if (nameTok.kind !== TokenKind.Identifier && nameTok.kind !== TokenKind.QuotedIdentifier) {
+            throw new ParseError('Expected a name after DiagramView (spec §18.1)', nameTok.start);
+        }
+        const name = this.parseIdentLikeName('DiagramView name');
+        // Spec §18.1 (v0.6.3): `note` and custom properties in the brackets.
+        // Other settings are reported by checkDiagramViews(), not here.
+        const settings = this.maybeSettingsBlock();
+        this.expect(TokenKind.LBrace, `Expected '{' after DiagramView ${name}`);
+        const categories = [];
+        const notes = [];
+        let wildcardBody = false;
+        for (;;) {
+            this.skipListSeparators();
+            const t = this.peek();
+            if (t.kind === TokenKind.RBrace || t.kind === TokenKind.EOF)
+                break;
+            if (this.atNoteElement()) {
+                notes.push(this.parseNoteBlockOrSetting());
+                continue;
+            }
+            if (t.kind === TokenKind.Star) {
+                if (categories.length > 0 || wildcardBody) {
+                    throw new ParseError(`A '*' body lists every element of every category, so no category goes beside it in DiagramView ${name} (spec §18.1)`, t.start);
+                }
+                this.advance();
+                wildcardBody = true;
+                continue;
+            }
+            const k = kw(t);
+            const category = k ? DIAGRAM_VIEW_CATEGORIES[k] : undefined;
+            if (!category) {
+                if (k === 'edges') {
+                    throw new ParseError('Edges is not a DiagramView category: a Ref or an Edge appears in a diagram view when both ' +
+                        'of its ends do, so there is nothing to list (spec §18.1, §18.4)', t.start);
+                }
+                throw new ParseError(`Unknown DiagramView category ${JSON.stringify(t.text)}. Expected Tables, Views, Containers ` +
+                    '(or Schemas), TableGroups, SupertypeGroups or Notes, each followed by { names }, or a Note (spec §18.1)', t.start);
+            }
+            if (wildcardBody) {
+                throw new ParseError(`A '*' body lists every element of every category, so no category goes beside it in DiagramView ${name} (spec §18.1)`, t.start);
+            }
+            categories.push(this.parseDiagramViewCategory(category));
+        }
+        this.expect(TokenKind.RBrace, "Expected '}' closing DiagramView");
+        return {
+            kind: 'DiagramViewDeclaration',
+            name,
+            settings,
+            notes,
+            wildcardBody,
+            categories,
+            span: this.spanFrom(start),
+        };
+    }
+    parseDiagramViewCategory(category) {
+        const start = this.peek().start;
+        const keywordTok = this.advance();
+        this.expect(TokenKind.LBrace, `Expected '{' after ${keywordTok.text} in a DiagramView`);
+        const items = [];
+        let wildcard = false;
+        for (;;) {
+            this.skipListSeparators();
+            const t = this.peek();
+            if (t.kind === TokenKind.RBrace || t.kind === TokenKind.EOF)
+                break;
+            if (t.kind === TokenKind.Star) {
+                this.advance();
+                wildcard = true;
+                continue;
+            }
+            if (t.kind !== TokenKind.Identifier && t.kind !== TokenKind.QuotedIdentifier) {
+                throw new ParseError(`Expected a name or '*' in ${keywordTok.text} { }, got ${t.kind} ${JSON.stringify(t.text)}`, t.start);
+            }
+            this.advance();
+            let n = t.kind === TokenKind.QuotedIdentifier ? (t.value ?? '') : t.text;
+            while (this.check(TokenKind.Dot)) {
+                this.advance();
+                const next = this.peek();
+                if (next.kind !== TokenKind.Identifier && next.kind !== TokenKind.QuotedIdentifier) {
+                    throw new ParseError(`Expected identifier after '.' in ${keywordTok.text} { }`, next.start);
+                }
+                this.advance();
+                n += `.${next.kind === TokenKind.QuotedIdentifier ? (next.value ?? '') : next.text}`;
+            }
+            items.push({ kind: 'DiagramViewItem', name: n, span: this.spanFrom(t.start) });
+        }
+        this.expect(TokenKind.RBrace, `Expected '}' closing ${keywordTok.text}`);
+        return {
+            kind: 'DiagramViewCategory',
+            category,
+            keyword: keywordTok.text,
+            wildcard,
+            items,
+            span: this.spanFrom(start),
+        };
+    }
     /* ----- Indexes ----- */
     parseIndexes() {
         const start = this.peek().start;
@@ -2376,7 +2525,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/package.json

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