@xdbml/parse 0.6.1 → 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)
  * ----------------------------------------------------------------------- */

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/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';
 /**
  * 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,8 @@ import { SCALAR_TYPES, BSON_TYPES } from "./keywords.js";
 import { flatten } from "./module-resolver.js";
 import { checkRelationships } from "./relationships.js";
 import { checkSupertypeGroups } from "./supertypes.js";
-import { checkConstraints } from "./constraints.js";
+import { checkConstraints, checkTargets } from "./constraints.js";
+import { versionAtLeast } from "./relationships.js";
 import { checkViews } from "./views.js";
 /**
  * Read-only handle on the collected symbol table.
@@ -232,6 +233,7 @@ 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 };
@@ -241,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) {
@@ -313,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.1";
+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 {

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.2';
 /** Compare dotted version strings numerically: -1, 0 or 1. */
 export function compareVersions(a, b) {
     const pa = a.split('.').map((n) => Number(n) || 0);
@@ -1385,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,
@@ -2376,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/package.json

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