@dbml/parse 6.0.0 → 6.2.0-alpha.0

package/dist/src/core/parser/nodes.d.ts

@@ -38,15 +38,18 @@ export declare enum SyntaxNodeKind {
     CALL_EXPRESSION = "<call-expression>",
     PRIMARY_EXPRESSION = "<primary-expression>",
     GROUP_EXPRESSION = "<group-expression>",
-    DUMMY = "<dummy>",
+    COMMA_EXPRESSION = "<comma-expression>",
+    EMPTY = "<dummy>",
     ARRAY = "<array>"
 }
 export declare class ProgramNode extends SyntaxNode {
     body: ElementDeclarationNode[];
     eof?: SyntaxToken;
-    constructor({ body, eof }: {
+    source: string;
+    constructor({ body, eof, source }: {
         body?: ElementDeclarationNode[];
         eof?: SyntaxToken;
+        source: string;
     }, id: SyntaxNodeId);
 }
 export declare class ElementDeclarationNode extends SyntaxNode {
@@ -84,7 +87,7 @@ export declare class AttributeNode extends SyntaxNode {
         value?: NormalExpressionNode | IdentiferStreamNode;
     }, id: SyntaxNodeId);
 }
-export type NormalExpressionNode = PrefixExpressionNode | InfixExpressionNode | PostfixExpressionNode | BlockExpressionNode | ListExpressionNode | TupleExpressionNode | CallExpressionNode | PrimaryExpressionNode | FunctionExpressionNode | DummyNode | ArrayNode;
+export type NormalExpressionNode = PrefixExpressionNode | InfixExpressionNode | PostfixExpressionNode | BlockExpressionNode | ListExpressionNode | TupleExpressionNode | CommaExpressionNode | CallExpressionNode | PrimaryExpressionNode | FunctionExpressionNode | EmptyNode | ArrayNode;
 export type ExpressionNode = ElementDeclarationNode | NormalExpressionNode | FunctionApplicationNode;
 export declare class PrefixExpressionNode extends SyntaxNode {
     op?: SyntaxToken;
@@ -160,6 +163,14 @@ export declare class TupleExpressionNode extends SyntaxNode {
         tupleCloseParen?: SyntaxToken;
     }, id: SyntaxNodeId);
 }
+export declare class CommaExpressionNode extends SyntaxNode {
+    elementList: NormalExpressionNode[];
+    commaList: SyntaxToken[];
+    constructor({ elementList, commaList, }: {
+        elementList?: NormalExpressionNode[];
+        commaList?: SyntaxToken[];
+    }, id: SyntaxNodeId);
+}
 export declare class GroupExpressionNode extends TupleExpressionNode {
     constructor({ groupOpenParen, expression, groupCloseParen, }: {
         groupOpenParen?: SyntaxToken;
@@ -193,9 +204,9 @@ export declare class PrimaryExpressionNode extends SyntaxNode {
         expression?: LiteralNode | VariableNode;
     }, id: SyntaxNodeId);
 }
-export declare class DummyNode extends SyntaxNode {
-    constructor({ pre }: {
-        pre: Readonly<SyntaxNode> | Readonly<SyntaxToken>;
+export declare class EmptyNode extends SyntaxNode {
+    constructor({ prevToken }: {
+        prevToken: Readonly<SyntaxNode> | Readonly<SyntaxToken>;
     }, id: SyntaxNodeId);
 }
 export declare class ArrayNode extends SyntaxNode {

package/dist/src/core/parser/parser.d.ts

@@ -1,4 +1,3 @@
-import { CompileError } from '../errors';
 import { SyntaxToken } from '../lexer/tokens';
 import { default as Report } from '../report';
 import { ProgramNode, SyntaxNodeIdGenerator } from './nodes';
@@ -8,7 +7,8 @@ export default class Parser {
     private errors;
     private contextStack;
     private nodeFactory;
-    constructor(tokens: SyntaxToken[], nodeIdGenerator: SyntaxNodeIdGenerator);
+    private source;
+    constructor(source: string, tokens: SyntaxToken[], nodeIdGenerator: SyntaxNodeIdGenerator);
     private isAtEnd;
     private advance;
     private peek;
@@ -22,7 +22,7 @@ export default class Parser {
     parse(): Report<{
         ast: ProgramNode;
         tokens: SyntaxToken[];
-    }, CompileError>;
+    }>;
     private program;
     private synchronizeProgram;
     private elementDeclaration;
@@ -30,7 +30,9 @@ export default class Parser {
     private synchronizeElementDeclarationAlias;
     private fieldDeclaration;
     private expression;
-    private shouldStopExpression;
+    private shouldStopFunctionApplication;
+    private commaExpression;
+    private shouldStopCommaExpression;
     private normalExpression;
     private expression_bp;
     private leftExpression_bp;

package/dist/src/core/parser/utils.d.ts

@@ -1,8 +1,8 @@
 import { SyntaxToken, SyntaxTokenKind } from '../lexer/tokens';
 import { Option } from '../option';
 import { default as NodeFactory } from './factory';
-import { ElementDeclarationNode, ExpressionNode, IdentiferStreamNode, InfixExpressionNode, LiteralNode, NormalExpressionNode, PrimaryExpressionNode, SyntaxNode, VariableNode } from './nodes';
-export declare function convertFuncAppToElem(callee: ExpressionNode | undefined, args: NormalExpressionNode[], factory: NodeFactory): Option<ElementDeclarationNode>;
+import { CommaExpressionNode, ElementDeclarationNode, ExpressionNode, IdentiferStreamNode, InfixExpressionNode, LiteralNode, NormalExpressionNode, PrimaryExpressionNode, SyntaxNode, VariableNode } from './nodes';
+export declare function convertFuncAppToElem(_callee: ExpressionNode | CommaExpressionNode | undefined, _args: (NormalExpressionNode | CommaExpressionNode)[], factory: NodeFactory): Option<ElementDeclarationNode>;
 export declare function isAsKeyword(token?: SyntaxToken): token is SyntaxToken & {
     kind: SyntaxTokenKind.IDENTIFIER;
     value: 'as';
@@ -49,5 +49,5 @@ type DotDelimitedIdentifier = PrimaryExpressionNode | (AccessExpression & {
 export declare function isAccessExpression(node?: SyntaxNode): node is AccessExpression;
 export declare function isDotDelimitedIdentifier(node?: SyntaxNode): node is DotDelimitedIdentifier;
 export declare function extractStringFromIdentifierStream(stream?: IdentiferStreamNode): Option<string>;
-export declare function getElementName(element: ElementDeclarationNode): Option<string>;
+export declare function getElementNameString(element?: ElementDeclarationNode): Option<string>;
 export {};

package/dist/src/core/report.d.ts

@@ -1,9 +1,12 @@
-export default class Report<T, E> {
+import { CompileError, CompileWarning } from './errors';
+export default class Report<T> {
     private value;
     private errors;
-    constructor(value: T, errors?: E[]);
+    private warnings?;
+    constructor(value: T, errors?: CompileError[], warnings?: CompileWarning[]);
     getValue(): T;
-    getErrors(): E[];
-    chain<U>(fn: (_: T) => Report<U, E>): Report<U, E>;
-    map<U>(fn: (_: T) => U): Report<U, E>;
+    getErrors(): CompileError[];
+    getWarnings(): CompileWarning[];
+    chain<U>(fn: (_: T) => Report<U>): Report<U>;
+    map<U>(fn: (_: T) => U): Report<U>;
 }

package/dist/src/core/utils.d.ts

@@ -4,7 +4,6 @@ export declare function isAlphaOrUnderscore(char: string): boolean;
 export declare function isDigit(char: string): boolean;
 export declare function isHexChar(char: string): boolean;
 export declare function isAlphaNumeric(char: string): boolean;
-export declare function addQuoteIfNeeded(s: string): string;
 export declare function alternateLists<T, S>(firstList: T[], secondList: S[]): (T | S)[];
 export declare function isOffsetWithinFullSpan(offset: number, nodeOrToken: SyntaxNode | SyntaxToken): boolean;
 export declare function isOffsetWithinSpan(offset: number, nodeOrToken: SyntaxNode | SyntaxToken): boolean;

package/dist/src/index.d.ts

@@ -1,12 +1,11 @@
-import { serialize } from './core/serialization/serialize';
 import { default as Compiler } from './compiler/index';
 import * as services from '@/services/index';
 export { ElementKind, } from './core/analyzer/types';
+export * from './core/interpreter/records/utils';
 export { SyntaxNode, ElementDeclarationNode, ProgramNode, SyntaxNodeKind, type SyntaxNodeId, } from './core/parser/nodes';
 export { SyntaxToken, SyntaxTokenKind, } from './core/lexer/tokens';
 export { CompileError, CompileErrorCode, } from './core/errors';
 export { type Position, } from './core/types';
-export { addQuoteIfNeeded, } from './core/utils';
-export { ScopeKind, } from './compiler/index';
+export { ScopeKind, splitQualifiedIdentifier, unescapeString, escapeString, formatRecordValue, isValidIdentifier, addDoubleQuoteIfNeeded, } from './compiler/index';
 export { type Database, type Table, type Column, type Enum, type Ref, type Project, type TableGroup, type TablePartial, } from './core/interpreter/types';
-export { serialize, Compiler, services };
+export { Compiler, services };

package/dist/src/services/diagnostics/provider.d.ts

@@ -0,0 +1,34 @@
+import { default as Compiler } from '../../compiler';
+import { MarkerData } from '../types';
+interface Diagnostic {
+    type: 'error' | 'warning';
+    text: string;
+    startRow: number;
+    startColumn: number;
+    endRow: number;
+    endColumn: number;
+    code?: string | number;
+}
+export default class DBMLDiagnosticsProvider {
+    private compiler;
+    constructor(compiler: Compiler);
+    /**
+     * Get all diagnostics (errors and warnings) from the current compilation
+     */
+    provideDiagnostics(): Diagnostic[];
+    /**
+     * Get only errors from the current compilation
+     */
+    provideErrors(): Diagnostic[];
+    /**
+     * Get only warnings from the current compilation
+     */
+    provideWarnings(): Diagnostic[];
+    /**
+     * Convert Monaco markers format (for editor integration)
+     */
+    provideMarkers(): MarkerData[];
+    private createDiagnostic;
+    private getSeverityValue;
+}
+export {};

package/dist/src/services/index.d.ts

@@ -1,5 +1,6 @@
 import { default as DBMLCompletionItemProvider } from './suggestions/provider';
 import { default as DBMLDefinitionProvider } from './definition/provider';
 import { default as DBMLReferencesProvider } from './references/provider';
+import { default as DBMLDiagnosticsProvider } from './diagnostics/provider';
 export * from './types';
-export { DBMLCompletionItemProvider, DBMLDefinitionProvider, DBMLReferencesProvider, };
+export { DBMLCompletionItemProvider, DBMLDefinitionProvider, DBMLReferencesProvider, DBMLDiagnosticsProvider, };

package/dist/src/services/suggestions/recordRowSnippet.d.ts

@@ -0,0 +1,3 @@
+import { CompletionList, TextModel, Position } from '../types';
+import { default as Compiler } from '../../compiler';
+export declare function suggestRecordRowSnippet(compiler: Compiler, model: TextModel, position: Position, offset: number): CompletionList | null;

package/dist/src/services/suggestions/utils.d.ts

@@ -1,8 +1,34 @@
 import { SymbolKind } from '../../core/analyzer/symbol/symbolIndex';
 import { CompletionItemKind, CompletionList } from '../types';
 import { SyntaxToken } from '../../core/lexer/tokens';
+import { SyntaxNode, TupleExpressionNode } from '../../core/parser/nodes';
+import { default as Compiler } from '../../compiler';
+import { ColumnSymbol, TablePartialInjectedColumnSymbol, TablePartialSymbol, TableSymbol } from '../../core/analyzer/symbol/symbols';
 export declare function pickCompletionItemKind(symbolKind: SymbolKind): CompletionItemKind;
 export declare function shouldPrependSpace(token: SyntaxToken | undefined, offset: number): boolean;
 export declare function noSuggestions(): CompletionList;
 export declare function prependSpace(completionList: CompletionList): CompletionList;
-export declare function addQuoteIfNeeded(completionList: CompletionList): CompletionList;
+export declare function addQuoteToSuggestionIfNeeded(completionList: CompletionList): CompletionList;
+export declare function addSuggestAllSuggestion(completionList: CompletionList, separator?: string): CompletionList;
+export declare function getNodeOrTokenSource(compiler: Compiler, tokenOrNode: SyntaxToken | SyntaxNode): string;
+/**
+ * Checks if the offset is within the element's header
+ * (within the element, but outside the body)
+ */
+export declare function isOffsetWithinElementHeader(offset: number, element: SyntaxNode & {
+    body?: SyntaxNode;
+}): boolean;
+export declare function isTupleEmpty(tuple: TupleExpressionNode): boolean;
+/**
+ * Get columns from a table symbol
+ * @param tableSymbol The table symbol to extract columns from
+ * @returns Array of column objects with name and type information
+ */
+export declare function getColumnsFromTableSymbol(tableSymbol: TableSymbol | TablePartialSymbol): Array<{
+    name: string;
+    type: string;
+}> | null;
+export declare function extractNameAndTypeOfColumnSymbol(columnSymbol: ColumnSymbol | TablePartialInjectedColumnSymbol, columnName: string): {
+    name: string;
+    type: string;
+} | null;

package/dist/src/services/types.d.ts

@@ -12,8 +12,12 @@ export interface CompletionItemProvider {
     provideCompletionItems(model: TextModel, position: Position, context: CompletionContext, token: CancellationToken): ProviderResult<CompletionList>;
     resolveCompletionItem?(item: CompletionItem, token: CancellationToken): ProviderResult<CompletionItem>;
 }
-export type CompletionItem = languages.CompletionItem;
-export type CompletionList = languages.CompletionList;
+export type CompletionItem = languages.CompletionItem & {
+    quoted?: boolean;
+};
+export interface CompletionList extends languages.CompletionList {
+    suggestions: CompletionItem[];
+}
 export declare enum CompletionItemKind {
     Function = 1,
     Constructor = 2,
@@ -57,3 +61,10 @@ export type Definition = languages.Definition;
 export type CodeActionList = languages.CodeActionList;
 export type SignatureHelpResult = languages.SignatureHelpResult;
 export type ReferenceProvider = languages.ReferenceProvider;
+export declare enum MarkerSeverity {
+    Hint = 1,
+    Info = 2,
+    Warning = 4,
+    Error = 8
+}
+export type MarkerData = editor.IMarkerData;

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@dbml/parse",
-  "version": "6.0.0",
+  "version": "6.2.0-alpha.0",
   "description": "DBML parser v2",
   "author": "Holistics <dev@holistics.io>",
   "license": "Apache-2.0",
@@ -38,6 +38,7 @@
   "devDependencies": {
     "@stylistic/eslint-plugin": "^5.5.0",
     "@types/lodash-es": "^4.17.12",
+    "@types/luxon": "^3.7.1",
     "@types/node": "^20.8.8",
     "@typescript-eslint/eslint-plugin": "^8.46.3",
     "@typescript-eslint/parser": "^8.46.3",
@@ -49,10 +50,11 @@
     "vite-plugin-dts": "^4.5.4"
   },
   "dependencies": {
-    "lodash-es": "^4.17.21"
+    "lodash-es": "^4.17.21",
+    "luxon": "^3.7.2"
   },
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "75a218687814d8b1c538b26908745e0d0ee8b35a"
+  "gitHead": "00865dc46e1cbab39233ad010c6b5e120131476c"
 }

package/dist/src/core/serialization/serialize.d.ts

@@ -1,4 +0,0 @@
-import { ProgramNode } from '../parser/nodes';
-import { default as Report } from '../report';
-import { CompileError } from '../errors';
-export declare function serialize(report: Readonly<Report<ProgramNode, CompileError>>, pretty?: boolean): string;