@xdbml/parse 0.5.0 → 0.5.1

package/dist/ast.d.ts

@@ -81,7 +81,11 @@ export interface FieldDeclaration {
 export type TypeExpression = ScalarType | ObjectType | ArrayType | TupleType | MapType | SetType | UnionType | OneOfType | AnyOfType | AllOfType | JsonType | NamedTypeReference;
 export interface ScalarType {
     kind: 'ScalarType';
-    /** The base name: `int`, `varchar`, `decimal`, `objectId`, `Decimal128`, etc. */
+    /**
+     * The base name: `int`, `varchar`, `decimal`, `objectId`, `Decimal128`,
+     * etc. May be qualified, `core.job_status`, when it names an Enum
+     * declared in a container (spec §16).
+     */
     name: string;
     /** `(p, s)` parameters, e.g. for `decimal(19, 4)`. Numbers preserved as strings to keep round-trip fidelity. */
     params?: string[];
@@ -229,6 +233,11 @@ export interface EnumDeclaration {
     kind: 'EnumDeclaration';
     /** Source casing of `enum` or `Enum`; both are valid. */
     keywordCasing: string;
+    /**
+     * May be `container.enum` form when declared schema-qualified at the
+     * top level (`enum core.job_status`); the resolver files it under that
+     * container, like an Enum declared inside the Container block.
+     */
     name: string;
     values: EnumValue[];
     span: Span;

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 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", "replication", "location", "default_charset", "cloned_at"];
 export declare const GRANULARITY_VALUES: readonly ["year", "quarter", "month", "week", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"];

package/dist/keywords.js

@@ -98,9 +98,15 @@ export const POLYMORPHISM_KEYWORDS = [
 /* -------------------------------------------------------------------------
  * Scalar and BSON types
  *
- * The parser accepts any identifier as a scalar type (open vocabulary),
- * so these lists drive color, not validation. Themes color them under
- * `storage.type` (TextMate) or `type` (Monarch).
+ * The parser accepts any identifier as a scalar type (open vocabulary,
+ * spec §1.2 principle 4), so these lists never reject a type name.
+ * They serve two purposes: themes color them under `storage.type`
+ * (TextMate) or `type` (Monarch), and the name resolver treats them as
+ * built-in names, which a Named Type cannot shadow (spec §15.2).
+ * Adding a name here therefore changes resolution as well as color: a
+ * document declaring `Type <that name>` would stop resolving to its own
+ * Type. Target-native names that only need color go in
+ * TARGET_NATIVE_TYPES below.
  * ----------------------------------------------------------------------- */
 export const SCALAR_TYPES = [
     // Integers
@@ -139,6 +145,51 @@ export const BSON_TYPES = [
     'long',
     'double',
 ];
+/* -------------------------------------------------------------------------
+ * Target-native types (highlighting only)
+ *
+ * Common type names of specific targets, colored like SCALAR_TYPES so
+ * that a physical model reads the same in the editor as a generic one.
+ * Unlike SCALAR_TYPES, these are not built-in names: the resolver
+ * passes them through like any other target-native name, and a Named
+ * Type or Enum may be declared under one of them.
+ *
+ * Coloring is position-independent (Monarch and TextMate both match
+ * the bare word), so a field named after a listed type is colored as a
+ * type too. Generic words that often name fields -- `point`, `line`,
+ * `box`, `path`, `circle`, `image`, `counter`, `duration`, `name` --
+ * are left out for that reason. The list is a convenience, not a
+ * vocabulary: a name missing from it is still a valid type.
+ * ----------------------------------------------------------------------- */
+export const TARGET_NATIVE_TYPES = [
+    // Oracle
+    'number', 'binary_float', 'binary_double', 'clob', 'nclob', 'bfile',
+    'raw', 'rowid', 'urowid', 'xmltype', 'sdo_geometry',
+    // Oracle, PostgreSQL, BigQuery, Databricks
+    'interval',
+    // PostgreSQL
+    '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',
+    // SQL Server
+    'uniqueidentifier', 'datetimeoffset', 'smalldatetime', 'rowversion',
+    'hierarchyid', 'sql_variant',
+    // Snowflake (plus `number`, `interval`, `geography`, `geometry`)
+    'timestamp_ntz', 'timestamp_ltz', 'timestamp_tz', 'vector',
+    // BigQuery, Avro, Protobuf
+    'float64', 'bignumeric', 'bigdecimal', 'bytes',
+    // Spatial, across several targets
+    'geometry', 'geography',
+    // Cassandra
+    'ascii', 'varint', 'timeuuid',
+    // Protobuf
+    'uint32', 'uint64', 'sint32', 'sint64',
+    'fixed32', 'fixed64', 'sfixed32', 'sfixed64',
+    // ClickHouse
+    'uint8', 'uint16', 'int16', 'float32',
+];
 /* -------------------------------------------------------------------------
  * Settings vocabulary
  *

package/dist/module-resolver.js

@@ -390,8 +390,18 @@ function findImportTarget(item, doc) {
         }
         return undefined;
     }
-    // Enum: top-level OR container-scoped.
+    // Enum: top-level OR container-scoped. A top-level Enum declared with
+    // a qualified name (`enum core.job_status`, the DBML form) matches its
+    // full dotted path and imports under its bare name, like the
+    // container-scoped form: the source container does not survive into
+    // the importing file (spec §27.16).
     if (item.elementType === 'enum') {
+        if (segments.length > 1) {
+            const qualifiedTopLevel = doc.statements.find((s) => s.kind === 'EnumDeclaration' && s.name === path);
+            if (qualifiedTopLevel && qualifiedTopLevel.kind === 'EnumDeclaration') {
+                return { ...qualifiedTopLevel, name: segments[segments.length - 1] };
+            }
+        }
         if (segments.length === 1) {
             return doc.statements.find((s) => s.kind === 'EnumDeclaration' && s.name === segments[0]);
         }

package/dist/monarch.d.ts

@@ -53,6 +53,7 @@ export interface XDbmlMonarchLanguage {
     polymorphismKeywords: string[];
     scalarTypes: string[];
     bsonTypes: string[];
+    nativeTypes: string[];
     settingFlags: string[];
     settingKeys: string[];
     granularityValues: string[];

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, 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, } from "./keywords.js";
 /* -------------------------------------------------------------------------
  * Language configuration
  * ----------------------------------------------------------------------- */
@@ -102,6 +102,9 @@ export const xdbmlMonarchTokensProvider = {
     scalarTypes: [...SCALAR_TYPES],
     // BSON / document-store types
     bsonTypes: [...BSON_TYPES],
+    // Target-native types (Oracle `number`, PostgreSQL `serial`, ...):
+    // colored like scalar types, but not built-ins -- see keywords.ts.
+    nativeTypes: [...TARGET_NATIVE_TYPES],
     // Bare-flag settings: `pk`, `unique`, `not null`, etc.
     // `not null` and `primary key` are two words but tokenized one at a time
     // here -- the highlighter colors each as `keyword.setting`.
@@ -165,6 +168,7 @@ export const xdbmlMonarchTokensProvider = {
                         '@decls': 'keyword.declaration',
                         '@scalarTypes': 'type',
                         '@bsonTypes': 'type.bson',
+                        '@nativeTypes': 'type',
                         '@settingFlags': 'keyword.setting',
                         '@settingKeys': 'keyword.setting',
                         '@granularityValues': 'keyword.value',

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' | 'unresolved-entity' | 'unresolved-field' | 'unresolved-partial' | 'unresolved-tablegroup-member' | 'unresolved-records-entity' | 'unresolved-records-column' | 'empty-import' | 'invalid-nested-path' | 'foreign-master-composite' | 'foreign-master-duplicate-child' | 'foreign-master-without-ref' | 'construct-requires-version' | 'ambiguous-ref-endpoint' | 'invalid-constraint-type' | 'constraint-type-on-foreign-master' | 'invalid-undirected' | 'entity-level-many-to-many' | 'missing-supertype' | 'unresolved-supertype-group-member' | 'invalid-supertype-group-value' | 'duplicate-subtype' | 'supertype-is-subtype' | 'subtype-in-multiple-groups' | 'supertype-cycle' | 'supertype-attribute-redeclared' | 'discriminator-on-overlapping-group' | 'merge-without-roll-up' | 'empty-supertype-group';
+export type DiagnosticCode = 'duplicate-declaration' | 'unresolved-type' | 'possible-type-typo' | 'unresolved-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';
 /**
  * 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

@@ -96,11 +96,18 @@ export class SymbolTable {
  * Built-in type recognition
  *
  * Field type expressions can name a builtin scalar (`int`, `varchar`),
- * a BSON type (`objectId`), or a user-defined Named Type (`Email`).
- * The parser doesn't distinguish at parse time -- they all land as
+ * a BSON type (`objectId`), a user-defined Named Type (`Email`) or Enum,
+ * or any other target-native type (`number`, `clob`, `serial`). The
+ * parser doesn't distinguish at parse time -- they all land as
  * ScalarType nodes (or NamedTypeReference in some contexts). The
- * resolver uses these sets to decide whether to look up a name in the
- * symbol table.
+ * resolver uses these sets only to skip the symbol-table lookup for
+ * names that can never be a Named Type reference.
+ *
+ * The sets are not a type vocabulary. Scalar type names pass through
+ * as written (spec §1.2, principle 4), so a name that is neither a
+ * builtin nor a declared Type or Enum is a target-native type, not an
+ * error. See `nearMissTypeName()` for the one diagnostic such a name
+ * can raise.
  *
  * Matching is case-insensitive: `Int`, `int`, `INT` all map to the same
  * builtin per spec §3.8.
@@ -112,6 +119,87 @@ const BUILTIN_TYPES = new Set([
 function isBuiltinType(name) {
     return BUILTIN_TYPES.has(name.toLowerCase());
 }
+/**
+ * The declared Types and Enums a bare type name can refer to. More than
+ * one entry means the name is declared in several containers (Enums can
+ * be container-scoped); the name still refers to a declaration, so it
+ * is neither a target-native type nor a near miss.
+ */
+function typeOrEnumDeclarations(name, symbols) {
+    const qualified = symbols.lookup(name);
+    if (qualified && (qualified.kind === 'type' || qualified.kind === 'enum'))
+        return [qualified];
+    return symbols.lookupAllBare(name).filter((e) => e.kind === 'type' || e.kind === 'enum');
+}
+/**
+ * Near-miss detection for target-native type names.
+ *
+ * A type name that is neither a builtin nor a declared Type or Enum is
+ * accepted as a target-native type. The one case worth flagging is a
+ * name that differs only slightly from a declared Type or Enum -- most
+ * likely a misspelling (`Adress` for `Address`, `email` for `Email`).
+ * Returns the declared name to suggest, or undefined when nothing is
+ * close enough.
+ *
+ * Comparison is case-insensitive, so a difference of case alone counts
+ * as a near miss (identifiers are case-sensitive, spec §3.8). The edit
+ * distance allowed grows with the length of the name: none beyond case
+ * for three characters or fewer, one edit up to seven characters, two
+ * edits from eight. An adjacent transposition counts as one edit.
+ */
+function nearMissTypeName(name, symbols) {
+    const lower = name.toLowerCase();
+    const maxDistance = lower.length <= 3 ? 0 : lower.length <= 7 ? 1 : 2;
+    // A qualified name (`core.job_stauts`) compares against qualified
+    // declarations, a bare name against bare ones.
+    const qualified = name.includes('.');
+    let best;
+    for (const entry of symbols.entries()) {
+        if (entry.kind !== 'type' && entry.kind !== 'enum')
+            continue;
+        const declared = qualified ? entry.qualifiedName : entry.name;
+        const candidate = declared.toLowerCase();
+        if (Math.abs(candidate.length - lower.length) > maxDistance)
+            continue;
+        const distance = editDistance(lower, candidate, maxDistance);
+        if (distance <= maxDistance && (!best || distance < best.distance)) {
+            best = { name: declared, distance };
+        }
+    }
+    return best?.name;
+}
+/**
+ * Optimal string alignment distance (Levenshtein plus adjacent
+ * transposition). Returns `limit + 1` as soon as every alignment of a
+ * row exceeds `limit`, since callers only compare against the limit.
+ */
+function editDistance(a, b, limit) {
+    const rows = a.length + 1;
+    const cols = b.length + 1;
+    const d = [];
+    for (let i = 0; i < rows; i++) {
+        d.push(new Array(cols).fill(0));
+        d[i][0] = i;
+    }
+    for (let j = 0; j < cols; j++)
+        d[0][j] = j;
+    for (let i = 1; i < rows; i++) {
+        let rowMin = Infinity;
+        for (let j = 1; j < cols; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            let v = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
+            if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+                v = Math.min(v, d[i - 2][j - 2] + 1);
+            }
+            d[i][j] = v;
+            if (v < rowMin)
+                rowMin = v;
+        }
+        if (rowMin > limit)
+            return limit + 1;
+    }
+    return d[rows - 1][cols - 1];
+}
 /* -------------------------------------------------------------------------
  * Main entry point
  * ----------------------------------------------------------------------- */
@@ -159,9 +247,20 @@ function addTopLevelDeclaration(stmt, entries, diagnostics, seen) {
         case 'TypeDeclaration':
             addEntry(stmt.name, undefined, 'type', stmt, stmt.span, entries, diagnostics, seen);
             return;
-        case 'EnumDeclaration':
-            addEntry(stmt.name, undefined, 'enum', stmt, stmt.span, entries, diagnostics, seen);
+        case 'EnumDeclaration': {
+            // `enum core.job_status { ... }` (the DBML form) files the Enum
+            // under container `core`, exactly as `Container core { Enum
+            // job_status { ... } }` does: same qualified name, same bare name,
+            // and declaring both is a duplicate (spec §16).
+            const dot = stmt.name.lastIndexOf('.');
+            if (dot > 0) {
+                addEntry(stmt.name.slice(dot + 1), stmt.name.slice(0, dot), 'enum', stmt, stmt.span, entries, diagnostics, seen);
+            }
+            else {
+                addEntry(stmt.name, undefined, 'enum', stmt, stmt.span, entries, diagnostics, seen);
+            }
             return;
+        }
         case 'EdgeDeclaration':
             addEntry(stmt.name, undefined, 'edge', stmt, stmt.span, entries, diagnostics, seen);
             return;
@@ -363,16 +462,18 @@ function resolveFieldDeclaration(field, symbols, diagnostics) {
 function resolveTypeExpression(expr, symbols, diagnostics) {
     switch (expr.kind) {
         case 'ScalarType':
-            // A ScalarType is either a builtin or a reference to a Named Type
-            // (the parser doesn't distinguish at parse time). Look up only
-            // when the name isn't a builtin.
-            if (!isBuiltinType(expr.name)) {
-                const found = symbols.lookup(expr.name) ?? symbols.lookupBare(expr.name);
-                if (!found || found.kind !== 'type') {
+            // A ScalarType is a builtin, a reference to a declared Type or
+            // Enum, or a target-native type passed through as written (spec
+            // §1.2, principle 4) -- the parser doesn't distinguish at parse
+            // time. A target-native name is valid; the only diagnostic is a
+            // warning when it is a near miss of a declared Type or Enum.
+            if (!isBuiltinType(expr.name) && typeOrEnumDeclarations(expr.name, symbols).length === 0) {
+                const suggestion = nearMissTypeName(expr.name, symbols);
+                if (suggestion) {
                     diagnostics.push({
-                        severity: 'error',
-                        code: 'unresolved-type',
-                        message: `Type '${expr.name}' is not a built-in type or declared Named Type.`,
+                        severity: 'warning',
+                        code: 'possible-type-typo',
+                        message: `Type '${expr.name}' is not declared; did you mean '${suggestion}'? Otherwise it is kept as a target-native type.`,
                         span: expr.span,
                     });
                 }
@@ -824,9 +925,18 @@ function dereferenceNamedType(type, symbols, depth) {
         return type;
     }
     const sym = symbols.lookup(name) ?? symbols.lookupBare(name);
+    if (type.kind === 'ScalarType' && (!sym || sym.kind !== 'type')) {
+        // An Enum or a target-native type: an opaque scalar, so a path that
+        // navigates into it gets the walker's shape diagnostic. A name
+        // declared as a Type or Enum in several containers stays unresolved.
+        if (typeOrEnumDeclarations(name, symbols).length > 1)
+            return undefined;
+        return type;
+    }
     if (!sym || sym.kind !== 'type' || sym.declaration.kind !== 'TypeDeclaration') {
-        // Unresolved -- the field-type pass will diagnose this. Return
-        // undefined so the walker bails without emitting a duplicate error.
+        // Unresolved Named Type reference -- the field-type pass diagnoses
+        // this. Return undefined so the walker bails without emitting a
+        // duplicate error.
         return undefined;
     }
     const td = sym.declaration;

package/dist/parser.js

@@ -1289,7 +1289,14 @@ export class Parser {
             throw new ParseError(`Expected type name, got ${t.kind} ${JSON.stringify(t.text)}`, t.start);
         }
         this.advance();
-        const name = t.kind === TokenKind.QuotedIdentifier ? (t.value ?? '') : t.text;
+        let name = t.kind === TokenKind.QuotedIdentifier ? (t.value ?? '') : t.text;
+        // A qualified type name, `core.job_status`, names an Enum declared in
+        // a container (spec §16), or a target-native type such as
+        // `public.geometry` that passes through as written.
+        while (this.check(TokenKind.Dot)) {
+            this.advance();
+            name += `.${this.parseIdentLikeName('type name after dot')}`;
+        }
         let params;
         if (this.check(TokenKind.LParen)) {
             this.advance();
@@ -1455,7 +1462,13 @@ export class Parser {
     parseEnum() {
         const start = this.peek().start;
         const kwTok = this.advance(); // enum
-        const name = this.parseIdentLikeName('enum name');
+        // DBML form `enum core.job_status { ... }`: the qualifier names the
+        // container, as for a schema-qualified Table (spec §7.3, §16).
+        let name = this.parseIdentLikeName('enum name');
+        while (this.check(TokenKind.Dot)) {
+            this.advance();
+            name += `.${this.parseIdentLikeName('enum name after dot')}`;
+        }
         this.expect(TokenKind.LBrace, "Expected '{' after enum name");
         const values = [];
         while (!this.check(TokenKind.RBrace) && !this.check(TokenKind.EOF)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xdbml/parse",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Parser for xDBML (eXtended Database Markup Language), a strict superset of DBML 3.13.6: tokenizer, parser, module resolver, and name resolver.",
   "license": "Apache-2.0",
   "author": "Hackolade",