@dbml/parse 6.2.0-alpha.0 → 6.2.1

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

@@ -1,13 +1,11 @@
 import { ProgramNode } from '../core/parser/nodes';
 import { SyntaxToken } from '../core/lexer/tokens';
+import { CompileError } from '../core/errors';
 import { Database } from '../core/interpreter/types';
 import { default as Report } from '../core/report';
-import { DBMLCompletionItemProvider, DBMLDefinitionProvider, DBMLReferencesProvider, DBMLDiagnosticsProvider } from '../services/index';
+import { DBMLCompletionItemProvider, DBMLDefinitionProvider, DBMLReferencesProvider } from '../services/index';
 import { TextEdit, TableNameInput } from './queries/transform';
-import { splitQualifiedIdentifier, unescapeString, escapeString, formatRecordValue, isValidIdentifier, addDoubleQuoteIfNeeded } from './queries/utils';
 export { ScopeKind } from './types';
-export type { TextEdit, TableNameInput };
-export { splitQualifiedIdentifier, unescapeString, escapeString, formatRecordValue, isValidIdentifier, addDoubleQuoteIfNeeded };
 export default class Compiler {
     private source;
     private cache;
@@ -28,10 +26,9 @@ export default class Compiler {
             ast: ProgramNode;
             tokens: SyntaxToken[];
             rawDb?: Database;
-        }>;
+        }, CompileError>;
         ast: () => Readonly<ProgramNode>;
-        errors: () => readonly Readonly<import('..').CompileError>[];
-        warnings: () => readonly Readonly<import('../core/errors').CompileWarning>[];
+        errors: () => readonly Readonly<CompileError>[];
         tokens: () => Readonly<SyntaxToken>[];
         rawDb: () => Readonly<Database> | undefined;
         publicSymbolTable: () => Readonly<import('../core/analyzer/symbol/symbolTable').default>;
@@ -65,6 +62,5 @@ export default class Compiler {
         definitionProvider: DBMLDefinitionProvider;
         referenceProvider: DBMLReferencesProvider;
         autocompletionProvider: DBMLCompletionItemProvider;
-        diagnosticsProvider: DBMLDiagnosticsProvider;
     };
 }

package/dist/src/compiler/queries/parse.d.ts

@@ -1,12 +1,11 @@
 import { default as Compiler } from '../index';
 import { ProgramNode } from '../../core/parser/nodes';
 import { SyntaxToken } from '../../core/lexer/tokens';
-import { CompileError, CompileWarning } from '../../core/errors';
+import { CompileError } from '../../core/errors';
 import { Database } from '../../core/interpreter/types';
 import { default as SymbolTable } from '../../core/analyzer/symbol/symbolTable';
 export declare function ast(this: Compiler): Readonly<ProgramNode>;
 export declare function errors(this: Compiler): readonly Readonly<CompileError>[];
-export declare function warnings(this: Compiler): readonly Readonly<CompileWarning>[];
 export declare function tokens(this: Compiler): Readonly<SyntaxToken>[];
 export declare function rawDb(this: Compiler): Readonly<Database> | undefined;
 export declare function publicSymbolTable(this: Compiler): Readonly<SymbolTable>;

package/dist/src/compiler/queries/transform/index.d.ts

@@ -1,3 +1,2 @@
-export { renameTable } from './renameTable';
+export { renameTable, type TableNameInput } from './renameTable';
 export { applyTextEdits, type TextEdit } from './applyTextEdits';
-export { type TableNameInput } from './utils';

package/dist/src/compiler/queries/transform/renameTable.d.ts

@@ -1,5 +1,8 @@
 import { default as Compiler } from '../../index';
-import { TableNameInput } from './utils';
+export type TableNameInput = string | {
+    schema?: string;
+    table: string;
+};
 /**
  * Renames a table in the DBML source code.
  *

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

@@ -9,6 +9,5 @@ export declare const enum ScopeKind {
     CUSTOM = 7,
     TOPLEVEL = 8,
     TABLEPARTIAL = 9,
-    CHECKS = 10,
-    RECORDS = 11
+    CHECKS = 10
 }

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

@@ -1,10 +1,11 @@
 import { ProgramNode } from '../parser/nodes';
 import { default as Report } from '../report';
+import { CompileError } from '../errors';
 import { NodeSymbolIdGenerator } from './symbol/symbols';
 export default class Analyzer {
     private ast;
     private symbolFactory;
     constructor(ast: ProgramNode, symbolIdGenerator: NodeSymbolIdGenerator);
-    analyze(): Report<ProgramNode>;
-    validate(): Report<ProgramNode>;
+    analyze(): Report<ProgramNode, CompileError>;
+    validate(): Report<ProgramNode, CompileError>;
 }

package/dist/src/core/analyzer/binder/binder.d.ts

@@ -1,3 +1,4 @@
+import { CompileError } from '../../errors';
 import { ProgramNode } from '../../parser/nodes';
 import { default as Report } from '../../report';
 import { default as SymbolFactory } from '../symbol/factory';
@@ -6,5 +7,5 @@ export default class Binder {
     private symbolFactory;
     constructor(ast: ProgramNode, symbolFactory: SymbolFactory);
     private resolvePartialInjections;
-    resolve(): Report<ProgramNode>;
+    resolve(): Report<ProgramNode, CompileError>;
 }

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

@@ -12,10 +12,9 @@ import { default as TableGroupBinder } from './elementBinder/tableGroup';
 import { default as TablePartialBinder } from './elementBinder/tablePartial';
 import { SymbolKind } from '../symbol/symbolIndex';
 import { CompileError } from '../../errors';
-import { default as RecordsBinder } from './elementBinder/records';
 export declare function pickBinder(element: ElementDeclarationNode & {
     type: SyntaxToken;
-}): typeof ChecksBinder | typeof CustomBinder | typeof EnumBinder | typeof TableBinder | typeof TableGroupBinder | typeof ProjectBinder | typeof RefBinder | typeof NoteBinder | typeof IndexesBinder | typeof TablePartialBinder | typeof RecordsBinder;
+}): typeof ChecksBinder | typeof CustomBinder | typeof EnumBinder | typeof TableBinder | typeof TableGroupBinder | typeof ProjectBinder | typeof RefBinder | typeof NoteBinder | typeof IndexesBinder | typeof TablePartialBinder;
 export declare function scanNonListNodeForBinding(node?: SyntaxNode): {
     variables: (PrimaryExpressionNode & {
         expression: VariableNode;

package/dist/src/core/analyzer/types.d.ts

@@ -7,8 +7,7 @@ export declare enum ElementKind {
     Indexes = "indexes",
     TableGroup = "tablegroup",
     TablePartial = "tablepartial",
-    Check = "checks",
-    Records = "records"
+    Check = "checks"
 }
 export declare enum SettingName {
     Color = "color",

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

@@ -1,8 +1,8 @@
 import { Option } from '../option';
 import { ElementDeclarationNode, FunctionExpressionNode, InfixExpressionNode, PrimaryExpressionNode, SyntaxNode, VariableNode } from '../parser/nodes';
-import { SyntaxToken } from '../lexer/tokens';
 import { NodeSymbolIndex } from './symbol/symbolIndex';
 import { NodeSymbol } from './symbol/symbols';
+import { SyntaxToken } from '../lexer/tokens';
 import { ElementKind } from './types';
 export declare function getElementKind(node?: ElementDeclarationNode): Option<ElementKind>;
 export declare function destructureMemberAccessExpression(node?: SyntaxNode): Option<SyntaxNode[]>;
@@ -26,8 +26,6 @@ export declare function extractVarNameFromPrimaryVariable(node?: PrimaryExpressi
     expression: VariableNode;
 }): Option<string>;
 export declare function extractQuotedStringToken(value?: SyntaxNode): Option<string>;
-export declare function extractNumericLiteral(node?: SyntaxNode): number | null;
-export declare function extractReferee(node?: SyntaxNode): NodeSymbol | undefined;
 export declare function isBinaryRelationship(value?: SyntaxNode): value is InfixExpressionNode;
 export declare function isEqualTupleOperands(value: InfixExpressionNode): value is InfixExpressionNode;
 export declare function isValidIndexName(value?: SyntaxNode): value is (PrimaryExpressionNode & {
@@ -40,12 +38,4 @@ export declare function extractIndexName(value: (PrimaryExpressionNode & {
 }) | (FunctionExpressionNode & {
     value: SyntaxToken;
 })): string;
-export declare function destructureCallExpression(node?: SyntaxNode): Option<{
-    variables: (PrimaryExpressionNode & {
-        expression: VariableNode;
-    })[];
-    args: (PrimaryExpressionNode & {
-        expression: VariableNode;
-    })[];
-}>;
 export declare function findSymbol(id: NodeSymbolIndex, startElement: ElementDeclarationNode): NodeSymbol | undefined;

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

@@ -11,12 +11,12 @@ import { default as TableGroupValidator } from './elementValidators/tableGroup';
 import { default as SymbolTable } from '../symbol/symbolTable';
 import { default as SymbolFactory } from '../symbol/factory';
 import { default as Report } from '../../report';
+import { CompileError } from '../../errors';
 import { default as TablePartialValidator } from './elementValidators/tablePartial';
 import { default as ChecksValidator } from './elementValidators/checks';
-import { default as RecordsValidator } from './elementValidators/records';
 export declare function pickValidator(element: ElementDeclarationNode & {
     type: SyntaxToken;
-}): typeof CustomValidator | typeof EnumValidator | typeof TableValidator | typeof TableGroupValidator | typeof ProjectValidator | typeof RefValidator | typeof NoteValidator | typeof IndexesValidator | typeof TablePartialValidator | typeof ChecksValidator | typeof RecordsValidator;
+}): typeof CustomValidator | typeof EnumValidator | typeof TableValidator | typeof TableGroupValidator | typeof ProjectValidator | typeof RefValidator | typeof NoteValidator | typeof IndexesValidator | typeof TablePartialValidator | typeof ChecksValidator;
 export declare function isValidName(nameNode: SyntaxNode): boolean;
 export declare function isValidAlias(aliasNode: SyntaxNode): aliasNode is PrimaryExpressionNode & {
     expression: VariableNode;
@@ -62,4 +62,4 @@ export declare function isTupleOfVariables(value?: SyntaxNode): value is TupleEx
 export declare function isValidColumnType(type: SyntaxNode): boolean;
 export declare function aggregateSettingList(settingList?: ListExpressionNode): Report<{
     [index: string]: AttributeNode[];
-}>;
+}, CompileError>;

package/dist/src/core/analyzer/validator/validator.d.ts

@@ -1,4 +1,5 @@
 import { default as Report } from '../../report';
+import { CompileError } from '../../errors';
 import { ProgramNode } from '../../parser/nodes';
 import { default as SymbolFactory } from '../symbol/factory';
 export default class Validator {
@@ -6,5 +7,5 @@ export default class Validator {
     private publicSchemaSymbol;
     private symbolFactory;
     constructor(ast: ProgramNode, symbolFactory: SymbolFactory);
-    validate(): Report<ProgramNode>;
+    validate(): Report<ProgramNode, CompileError>;
 }

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

@@ -90,11 +90,6 @@ export declare enum CompileErrorCode {
     UNKNOWN_CHECK_SETTING = 3074,
     DUPLICATE_CHECK_SETTING = 3075,
     INVALID_CHECK_SETTING_VALUE = 3076,
-    INVALID_RECORDS_CONTEXT = 3077,
-    INVALID_RECORDS_NAME = 3078,
-    INVALID_RECORDS_FIELD = 3079,
-    DUPLICATE_COLUMN_REFERENCES_IN_RECORDS = 3080,
-    DUPLICATE_RECORDS_FOR_TABLE = 3081,
     BINDING_ERROR = 4000,
     UNSUPPORTED = 5000,
     CIRCULAR_REF = 5001,
@@ -106,16 +101,7 @@ export declare enum CompileErrorCode {
 export declare class CompileError extends Error {
     code: Readonly<CompileErrorCode>;
     diagnostic: Readonly<string>;
-    nodeOrToken: Readonly<SyntaxNode | SyntaxToken>;
-    start: Readonly<number>;
-    end: Readonly<number>;
-    constructor(code: number, message: string, nodeOrToken: SyntaxNode | SyntaxToken);
-    toWarning(): CompileWarning;
-}
-export declare class CompileWarning extends Error {
-    code: Readonly<CompileErrorCode>;
-    diagnostic: Readonly<string>;
-    nodeOrToken: Readonly<SyntaxNode | SyntaxToken>;
+    nodeOrToken: Readonly<SyntaxNode | SyntaxToken | readonly (SyntaxNode | SyntaxToken)[]>;
     start: Readonly<number>;
     end: Readonly<number>;
     constructor(code: number, message: string, nodeOrToken: SyntaxNode | SyntaxToken);

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

@@ -1,9 +1,10 @@
 import { ProgramNode } from '../parser/nodes';
+import { CompileError } from '../errors';
 import { Database, InterpreterDatabase } from './types';
 import { default as Report } from '../report';
 export default class Interpreter {
     ast: ProgramNode;
     env: InterpreterDatabase;
     constructor(ast: ProgramNode);
-    interpret(): Report<Database>;
+    interpret(): Report<Database, CompileError>;
 }

package/dist/src/core/interpreter/types.d.ts

@@ -1,4 +1,4 @@
-import { ElementDeclarationNode, FunctionApplicationNode, SyntaxNode } from '../parser/nodes';
+import { ElementDeclarationNode } from '../parser/nodes';
 import { Position } from '../types';
 import { CompileError } from '../errors';
 export interface TokenPosition {
@@ -24,34 +24,6 @@ export interface InterpreterDatabase {
     tablePartials: Map<ElementDeclarationNode, TablePartial>;
     aliases: Alias[];
     project: Map<ElementDeclarationNode, Project>;
-    records: Map<Table, TableRecordRow[]>;
-    recordsElements: ElementDeclarationNode[];
-    cachedMergedTables: Map<Table, Table>;
-    source: string;
-}
-export type RecordValueType = 'string' | 'bool' | 'integer' | 'real' | 'date' | 'time' | 'datetime' | string;
-export interface RecordValue {
-    value: any;
-    type: RecordValueType;
-}
-export interface TableRecordRow {
-    values: Record<string, {
-        value: any;
-        type: RecordValueType;
-        node?: SyntaxNode;
-    }>;
-    node: FunctionApplicationNode;
-    columnNodes: Record<string, SyntaxNode>;
-}
-export interface TableRecordsData {
-    table: Table;
-    rows: TableRecordRow[];
-}
-export interface TableRecord {
-    schemaName: string | undefined;
-    tableName: string;
-    columns: string[];
-    values: RecordValue[][];
 }
 export interface Database {
     schemas: [];
@@ -63,7 +35,6 @@ export interface Database {
     aliases: Alias[];
     project: Project;
     tablePartials: TablePartial[];
-    records: TableRecord[];
 }
 export interface Table {
     name: string;
@@ -90,14 +61,6 @@ export interface ColumnType {
     schemaName: string | null;
     type_name: string;
     args: string | null;
-    numericParams?: {
-        precision: number;
-        scale: number;
-    };
-    lengthParam?: {
-        length: number;
-    };
-    isEnum?: boolean;
 }
 export interface Column {
     name: string;
@@ -230,5 +193,5 @@ export type Project = Record<string, never> | {
         token: TokenPosition;
     };
     token: TokenPosition;
-    [index: string & Omit<any, 'name' | 'tables' | 'refs' | 'enums' | 'tableGroups' | 'note' | 'tablePartials' | 'records'>]: string;
+    [index: string & Omit<any, 'name' | 'tables' | 'refs' | 'enums' | 'tableGroups' | 'note' | 'tablePartials'>]: string;
 };

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

@@ -1,8 +1,9 @@
 import { ColumnSymbol } from '../analyzer/symbol/symbols';
 import { LiteralNode, PrimaryExpressionNode, SyntaxNode } from '../parser/nodes';
-import { ColumnType, RelationCardinality, Table, TokenPosition, InterpreterDatabase, Ref } from './types';
+import { ColumnType, RelationCardinality, Table, TokenPosition } from './types';
 import { SyntaxTokenKind } from '../lexer/tokens';
 import { default as Report } from '../report';
+import { CompileError } from '../errors';
 export declare function extractNamesFromRefOperand(operand: SyntaxNode, owner?: Table): {
     schemaName: string | null;
     tableName: string;
@@ -31,6 +32,4 @@ export declare function processDefaultValue(valueNode?: SyntaxNode): {
     type: 'string' | 'number' | 'boolean' | 'expression';
     value: string | number;
 } | undefined;
-export declare function processColumnType(typeNode: SyntaxNode, env: InterpreterDatabase): Report<ColumnType>;
-export declare function mergeTableAndPartials(table: Table, env: InterpreterDatabase): Table;
-export declare function extractInlineRefsFromTablePartials(table: Table, env: InterpreterDatabase): Ref[];
+export declare function processColumnType(typeNode: SyntaxNode): Report<ColumnType, CompileError>;

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

@@ -1,3 +1,4 @@
+import { CompileError } from '../errors';
 import { default as Report } from '../report';
 import { SyntaxToken, SyntaxTokenKind } from './tokens';
 export default class Lexer {
@@ -14,7 +15,7 @@ export default class Lexer {
     match(sequence: string): boolean;
     private addToken;
     private createToken;
-    lex(): Report<SyntaxToken[]>;
+    lex(): Report<SyntaxToken[], CompileError>;
     scanTokens(): void;
     gatherTrivia(): void;
     gatherInvalid(): void;

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

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

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

@@ -1,3 +1,4 @@
+import { CompileError } from '../errors';
 import { SyntaxToken } from '../lexer/tokens';
 import { default as Report } from '../report';
 import { ProgramNode, SyntaxNodeIdGenerator } from './nodes';
@@ -7,8 +8,7 @@ export default class Parser {
     private errors;
     private contextStack;
     private nodeFactory;
-    private source;
-    constructor(source: string, tokens: SyntaxToken[], nodeIdGenerator: SyntaxNodeIdGenerator);
+    constructor(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,9 +30,7 @@ export default class Parser {
     private synchronizeElementDeclarationAlias;
     private fieldDeclaration;
     private expression;
-    private shouldStopFunctionApplication;
-    private commaExpression;
-    private shouldStopCommaExpression;
+    private shouldStopExpression;
     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 { 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>;
+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>;
 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 getElementNameString(element?: ElementDeclarationNode): Option<string>;
+export declare function getElementName(element: ElementDeclarationNode): Option<string>;
 export {};

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

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

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

@@ -0,0 +1,4 @@
+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;

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

@@ -4,6 +4,7 @@ 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,11 +1,12 @@
+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 { ScopeKind, splitQualifiedIdentifier, unescapeString, escapeString, formatRecordValue, isValidIdentifier, addDoubleQuoteIfNeeded, } from './compiler/index';
+export { addQuoteIfNeeded, } from './core/utils';
+export { ScopeKind, } 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 { Compiler, services };
+export { serialize, Compiler, services };

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

@@ -1,6 +1,5 @@
 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, DBMLDiagnosticsProvider, };
+export { DBMLCompletionItemProvider, DBMLDefinitionProvider, DBMLReferencesProvider, };

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

@@ -1,34 +1,8 @@
 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 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;
+export declare function addQuoteIfNeeded(completionList: CompletionList): CompletionList;

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

@@ -12,12 +12,8 @@ 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 & {
-    quoted?: boolean;
-};
-export interface CompletionList extends languages.CompletionList {
-    suggestions: CompletionItem[];
-}
+export type CompletionItem = languages.CompletionItem;
+export type CompletionList = languages.CompletionList;
 export declare enum CompletionItemKind {
     Function = 1,
     Constructor = 2,
@@ -61,10 +57,3 @@ 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.2.0-alpha.0",
+  "version": "6.2.1",
   "description": "DBML parser v2",
   "author": "Holistics <dev@holistics.io>",
   "license": "Apache-2.0",
@@ -25,10 +25,10 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc --noEmit && vite build",
+    "build": "rm -rf ./dist && tsc --noEmit && vite build",
     "dev": "vite build --watch",
     "test": "vitest run",
-    "test:watch": "vitest tests",
+    "test:watch": "vitest watch",
     "coverage": "vitest run --coverage",
     "prepublish": "npm run build",
     "prepare": "npm run build",
@@ -36,25 +36,13 @@
     "lint:fix": "eslint --fix ."
   },
   "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",
-    "eslint": "^9.39.1",
-    "monaco-editor-core": "^0.44.0",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.46.3",
-    "vite": "^7.2.2",
-    "vite-plugin-dts": "^4.5.4"
+    "monaco-editor-core": "^0.44.0"
   },
   "dependencies": {
-    "lodash-es": "^4.17.21",
-    "luxon": "^3.7.2"
+    "lodash-es": "^4.17.21"
   },
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "00865dc46e1cbab39233ad010c6b5e120131476c"
+  "gitHead": "403ffd5a0d15bbf0f2b22db2c507659ce3f8fe35"
 }

package/dist/__tests__/examples/compiler/stringUtils.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/examples/interpreter/record/data.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/examples/interpreter/record/fk.test.d.ts

@@ -1 +0,0 @@
-export {};