@duckcodeailabs/dql-core 1.6.18 → 1.6.19

package/dist/parser/parser.js

@@ -1,6 +1,6 @@
 import { DiagnosticReporter, DQLSyntaxError } from '../errors/reporter.js';
 import { Lexer } from '../lexer/lexer.js';
-import { TokenType, CHART_TYPES, FILTER_TYPES, normalizeChartType } from '../lexer/token.js';
+import { TokenType, CHART_TYPES, FILTER_TYPES, SQL_START_KEYWORDS, normalizeChartType } from '../lexer/token.js';
 import { NodeKind, } from '../ast/nodes.js';
 const DRAFT_STRING_METADATA_FIELDS = new Set([
     'first_asked',
@@ -81,6 +81,9 @@ export class Parser {
         if (this.check(TokenType.BlockKeyword)) {
             return this.parseBlockDecl(decorators);
         }
+        if (this.check(TokenType.DomainKeyword)) {
+            return this.parseDomainDecl(decorators);
+        }
         if (this.check(TokenType.TermKeyword)) {
             return this.parseTermDecl(decorators);
         }
@@ -96,7 +99,7 @@ export class Parser {
         if (this.check(TokenType.EOF)) {
             return null;
         }
-        this.error(`Unexpected token '${this.current().value}'. Expected 'dashboard', 'digest', 'workbook', 'chart', 'block', 'term', 'business_view', or 'import'.`);
+        this.error(`Unexpected token '${this.current().value}'. Expected 'dashboard', 'digest', 'workbook', 'chart', 'domain', 'block', 'term', 'business_view', or 'import'.`);
         return null;
     }
     parseFilterCall() {
@@ -631,6 +634,90 @@ export class Parser {
     makeSpan(start, end) {
         return { start: start.start, end: end.end };
     }
+    // ---- Domain Declaration ----
+    parseDomainDecl(decorators) {
+        const start = decorators.length > 0 ? decorators[0].span : this.currentSpan();
+        this.expect(TokenType.DomainKeyword);
+        const nameToken = this.expect(TokenType.StringLiteral);
+        this.expect(TokenType.LeftBrace);
+        let owner;
+        let businessOwner;
+        let boundedContext;
+        let sourceSystems;
+        let primaryTerms;
+        let reviewCadence;
+        let tags;
+        let businessOutcome;
+        let description;
+        while (!this.check(TokenType.RightBrace) && !this.isAtEnd()) {
+            if (this.check(TokenType.OwnerKeyword)) {
+                this.advance();
+                this.expect(TokenType.Equals);
+                owner = this.expect(TokenType.StringLiteral).value;
+            }
+            else if (this.check(TokenType.DescriptionKeyword)) {
+                this.advance();
+                this.expect(TokenType.Equals);
+                description = this.expectStringLike().value;
+            }
+            else if (this.check(TokenType.TagsKeyword)) {
+                this.advance();
+                this.expect(TokenType.Equals);
+                tags = this.parseStringArrayValues();
+            }
+            else if (this.check(TokenType.Identifier)
+                && (this.current().value === 'businessOwner'
+                    || this.current().value === 'boundedContext'
+                    || this.current().value === 'sourceSystems'
+                    || this.current().value === 'primaryTerms'
+                    || this.current().value === 'reviewCadence'
+                    || this.current().value === 'businessOutcome')) {
+                const keyToken = this.advance();
+                this.expect(TokenType.Equals);
+                if (keyToken.value === 'businessOwner') {
+                    businessOwner = this.expect(TokenType.StringLiteral).value;
+                }
+                else if (keyToken.value === 'boundedContext') {
+                    boundedContext = this.expectStringLike().value;
+                }
+                else if (keyToken.value === 'sourceSystems') {
+                    sourceSystems = this.parseStringArrayValues();
+                }
+                else if (keyToken.value === 'primaryTerms') {
+                    primaryTerms = this.parseStringArrayValues();
+                }
+                else if (keyToken.value === 'reviewCadence') {
+                    reviewCadence = this.expect(TokenType.StringLiteral).value;
+                }
+                else if (keyToken.value === 'businessOutcome') {
+                    businessOutcome = this.expect(TokenType.StringLiteral).value;
+                }
+            }
+            else if (this.check(TokenType.RightBrace)) {
+                break;
+            }
+            else {
+                this.error(`Unexpected token '${this.current().value}' inside domain. Expected 'owner', 'businessOwner', 'boundedContext', 'sourceSystems', 'primaryTerms', 'reviewCadence', 'tags', 'businessOutcome', 'description', or '}'.`);
+                this.advance();
+            }
+        }
+        this.expect(TokenType.RightBrace);
+        return {
+            kind: NodeKind.DomainDecl,
+            name: nameToken.value,
+            owner,
+            businessOwner,
+            boundedContext,
+            sourceSystems,
+            primaryTerms,
+            reviewCadence,
+            tags,
+            businessOutcome,
+            description,
+            decorators,
+            span: this.makeSpan(start, this.previousSpan()),
+        };
+    }
     // ---- Business Term Declaration ----
     parseTermDecl(decorators) {
         const start = decorators.length > 0 ? decorators[0].span : this.currentSpan();
@@ -928,11 +1015,20 @@ export class Parser {
         let blockType;
         let metricRef;
         let metricsRef;
-        let dimensionsRef;
+        let parsedDimensions;
         let description;
         let tags;
         let owner;
         let termRefs;
+        let pattern;
+        let grain;
+        let entities;
+        let outputs;
+        let allowedFilters;
+        let parameterPolicy;
+        let filterBindings;
+        let sourceSystems;
+        let replacementFor;
         let params;
         let query;
         let visualization;
@@ -1015,7 +1111,7 @@ export class Parser {
                 this.expect(TokenType.Equals);
                 const arrExpr = this.parseArrayLiteral();
                 if (arrExpr.kind === NodeKind.ArrayLiteral) {
-                    dimensionsRef = arrExpr.elements
+                    parsedDimensions = arrExpr.elements
                         .filter((e) => e.kind === NodeKind.StringLiteral)
                         .map((e) => e.value);
                 }
@@ -1047,25 +1143,72 @@ export class Parser {
                 this.expect(TokenType.Equals);
                 termRefs = this.parseStringArrayValues();
             }
+            else if (this.check(TokenType.Identifier)
+                && (this.current().value === 'grain'
+                    || this.current().value === 'pattern'
+                    || this.current().value === 'entities'
+                    || this.current().value === 'outputs'
+                    || this.current().value === 'allowedFilters'
+                    || this.current().value === 'sourceSystems'
+                    || this.current().value === 'replacementFor')) {
+                const keyToken = this.advance();
+                this.expect(TokenType.Equals);
+                if (keyToken.value === 'pattern') {
+                    const val = this.expect(TokenType.StringLiteral);
+                    pattern = val.value;
+                }
+                else if (keyToken.value === 'grain') {
+                    const val = this.expect(TokenType.StringLiteral);
+                    grain = val.value;
+                }
+                else if (keyToken.value === 'entities') {
+                    entities = this.parseStringArrayValues();
+                }
+                else if (keyToken.value === 'outputs') {
+                    outputs = this.parseStringArrayValues();
+                }
+                else if (keyToken.value === 'allowedFilters') {
+                    allowedFilters = this.parseStringArrayValues();
+                }
+                else if (keyToken.value === 'sourceSystems') {
+                    sourceSystems = this.parseStringArrayValues();
+                }
+                else if (keyToken.value === 'replacementFor') {
+                    replacementFor = this.parseStringArrayValues();
+                }
+            }
             else if (this.check(TokenType.ParamsKeyword)) {
                 params = this.parseBlockParams();
             }
+            else if (this.check(TokenType.Identifier)
+                && this.current().value === 'parameterPolicy') {
+                parameterPolicy = this.parseBlockParameterPolicy();
+            }
+            else if (this.check(TokenType.Identifier)
+                && this.current().value === 'filterBindings') {
+                filterBindings = this.parseBlockFilterBindings();
+            }
             else if (this.check(TokenType.QueryKeyword)) {
                 this.advance();
-                this.expect(TokenType.Equals);
-                if (this.check(TokenType.TripleQuoteString)) {
-                    const sqlToken = this.advance();
-                    const interpolations = this.extractInterpolations(sqlToken.value, sqlToken.span);
-                    query = {
-                        kind: NodeKind.SQLQuery,
-                        rawSQL: sqlToken.value,
-                        interpolations,
-                        span: sqlToken.span,
-                    };
+                if (this.check(TokenType.LeftBrace)) {
+                    query = this.parseLegacyBlockQuerySection();
                 }
                 else {
-                    // Fallback: parse as inline SQL
-                    query = this.parseSQLQuery();
+                    this.expect(TokenType.Equals);
+                    if (this.check(TokenType.TripleQuoteString)) {
+                        const sqlToken = this.advance();
+                        const interpolations = this.extractInterpolations(sqlToken.value, sqlToken.span);
+                        query = {
+                            kind: NodeKind.SQLQuery,
+                            rawSQL: sqlToken.value,
+                            interpolations,
+                            span: sqlToken.span,
+                        };
+                    }
+                    else {
+                        // Fallback: parse as inline SQL
+                        query = this.parseSQLQuery();
+                    }
                 }
             }
             else if (this.check(TokenType.VisualizationKeyword)) {
@@ -1264,13 +1407,13 @@ export class Parser {
                     this.skipBalancedBlock();
                     continue;
                 }
-                this.error(`Unexpected token '${this.current().value}' inside block. Expected 'domain', 'type', 'status', 'datalex_contract', 'metric', 'metrics', 'dimensions', 'description', 'tags', 'owner', 'terms', 'params', 'query', 'visualization', 'tests', 'llmContext', 'invariants', 'examples', 'businessOutcome', 'businessOwner', 'decisionUse', 'reviewCadence', 'businessRules', 'caveats', Tier-2 draft metadata fields, or '}'.`);
+                this.error(`Unexpected token '${this.current().value}' inside block. Expected 'domain', 'type', 'status', 'datalex_contract', 'metric', 'metrics', 'dimensions', 'description', 'tags', 'owner', 'terms', 'pattern', 'grain', 'entities', 'outputs', 'allowedFilters', 'parameterPolicy', 'filterBindings', 'sourceSystems', 'replacementFor', 'params', 'query', 'visualization', 'tests', 'llmContext', 'invariants', 'examples', 'businessOutcome', 'businessOwner', 'decisionUse', 'reviewCadence', 'businessRules', 'caveats', Tier-2 draft metadata fields, or '}'.`);
                 this.advance();
             }
         }
         if (!blockType) {
-            this.error(`Block "${nameToken.value}" is missing a required type declaration. Add type = "semantic" for dbt metric blocks or type = "custom" for SQL blocks.`);
-            blockType = 'custom'; // error-recovery default — keeps downstream analysis working
+            blockType = 'custom';
+            this.reporter.warning(`Block "${nameToken.value}" is missing a type declaration. DQL treated it as type = "custom" for backward compatibility.`, nameToken.span);
         }
         this.expect(TokenType.RightBrace);
         return {
@@ -1280,11 +1423,21 @@ export class Parser {
             blockType,
             metricRef,
             metricsRef,
-            dimensionsRef,
+            dimensionsRef: blockType === 'semantic' ? parsedDimensions : undefined,
             description,
             tags,
             owner,
             termRefs,
+            pattern,
+            grain,
+            entities,
+            outputs,
+            dimensions: blockType === 'semantic' ? undefined : parsedDimensions,
+            allowedFilters,
+            parameterPolicy,
+            filterBindings,
+            sourceSystems,
+            replacementFor,
             params,
             query,
             visualization,
@@ -1319,6 +1472,43 @@ export class Parser {
             span: this.makeSpan(start, this.previousSpan()),
         };
     }
+    parseLegacyBlockQuerySection() {
+        const start = this.currentSpan();
+        this.expect(TokenType.LeftBrace);
+        let query;
+        while (!this.check(TokenType.RightBrace) && !this.isAtEnd()) {
+            if (this.check(TokenType.Identifier) && this.current().value === 'sql') {
+                this.advance();
+                this.expect(TokenType.Equals);
+                if (this.check(TokenType.TripleQuoteString)) {
+                    const sqlToken = this.advance();
+                    const interpolations = this.extractInterpolations(sqlToken.value, sqlToken.span);
+                    query = {
+                        kind: NodeKind.SQLQuery,
+                        rawSQL: sqlToken.value,
+                        interpolations,
+                        span: sqlToken.span,
+                    };
+                }
+                else {
+                    query = this.parseSQLQuery();
+                }
+            }
+            else if (this.check(TokenType.Identifier)
+                && SQL_START_KEYWORDS.has(this.current().value.toUpperCase())) {
+                query = this.parseSQLQuery();
+            }
+            else {
+                this.error(`Unexpected token '${this.current().value}' inside query section. Expected 'sql' or inline SQL.`);
+                this.advance();
+            }
+        }
+        this.expect(TokenType.RightBrace);
+        if (!query) {
+            this.reporter.error('Query section must contain sql = """...""" or inline SQL.', this.makeSpan(start, this.previousSpan()));
+        }
+        return query;
+    }
     parseBlockParams() {
         const start = this.currentSpan();
         this.expect(TokenType.ParamsKeyword);
@@ -1350,6 +1540,58 @@ export class Parser {
             span: this.makeSpan(start, this.previousSpan()),
         };
     }
+    parseBlockParameterPolicy() {
+        const entries = [];
+        this.expect(TokenType.Identifier);
+        this.expect(TokenType.LeftBrace);
+        while (!this.check(TokenType.RightBrace) && !this.isAtEnd()) {
+            const entryStart = this.currentSpan();
+            const nameToken = this.current();
+            if (nameToken.type === TokenType.Identifier || this.isBlockFieldKeyword(nameToken.type)) {
+                this.advance();
+            }
+            else {
+                this.error(`Expected parameter name inside parameterPolicy, got '${nameToken.value}'.`);
+                this.advance();
+                continue;
+            }
+            this.expect(TokenType.Equals);
+            const policy = this.expectStringLike();
+            entries.push({
+                name: nameToken.value,
+                policy: policy.value,
+                span: this.makeSpan(entryStart, this.previousSpan()),
+            });
+        }
+        this.expect(TokenType.RightBrace);
+        return entries;
+    }
+    parseBlockFilterBindings() {
+        const entries = [];
+        this.expect(TokenType.Identifier);
+        this.expect(TokenType.LeftBrace);
+        while (!this.check(TokenType.RightBrace) && !this.isAtEnd()) {
+            const entryStart = this.currentSpan();
+            const nameToken = this.current();
+            if (nameToken.type === TokenType.Identifier || this.isBlockFieldKeyword(nameToken.type)) {
+                this.advance();
+            }
+            else {
+                this.error(`Expected business filter name inside filterBindings, got '${nameToken.value}'.`);
+                this.advance();
+                continue;
+            }
+            this.expect(TokenType.Equals);
+            const binding = this.expectStringLike();
+            entries.push({
+                filter: nameToken.value,
+                binding: binding.value,
+                span: this.makeSpan(entryStart, this.previousSpan()),
+            });
+        }
+        this.expect(TokenType.RightBrace);
+        return entries;
+    }
     parseBlockVisualization() {
         const start = this.currentSpan();
         this.expect(TokenType.VisualizationKeyword);