@dbml/parse 6.5.0 → 7.0.0-alpha.1

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

@@ -3,10 +3,10 @@ import { SyntaxToken } from '../core/lexer/tokens';
 import { Database } from '../core/interpreter/types';
 import { default as Report } from '../core/report';
 import { DBMLCompletionItemProvider, DBMLDefinitionProvider, DBMLReferencesProvider, DBMLDiagnosticsProvider } from '../services/index';
-import { TextEdit, TableNameInput } from './queries/transform';
+import { TextEdit, TableNameInput, DiagramViewSyncOperation, DiagramViewBlock } from './queries/transform';
 import { splitQualifiedIdentifier, unescapeString, escapeString, formatRecordValue, isValidIdentifier, addDoubleQuoteIfNeeded } from './queries/utils';
 export { ScopeKind } from './types';
-export type { TextEdit, TableNameInput };
+export type { TextEdit, TableNameInput, DiagramViewSyncOperation, DiagramViewBlock };
 export { splitQualifiedIdentifier, unescapeString, escapeString, formatRecordValue, isValidIdentifier, addDoubleQuoteIfNeeded };
 export default class Compiler {
     private source;
@@ -17,6 +17,11 @@ export default class Compiler {
     private query;
     private interpret;
     renameTable(oldName: TableNameInput, newName: TableNameInput): string;
+    syncDiagramView(operations: DiagramViewSyncOperation[], blocks?: DiagramViewBlock[]): {
+        newDbml: string;
+        edits: TextEdit[];
+    };
+    findDiagramViewBlocks(): DiagramViewBlock[];
     applyTextEdits(edits: TextEdit[]): string;
     readonly token: {
         invalidStream: () => readonly SyntaxToken[];

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

@@ -10,4 +10,4 @@ export interface TextEdit {
  * @param edits - Array of text edits to apply
  * @returns The modified source string with all edits applied
  */
-export declare function applyTextEdits(source: string, edits: TextEdit[]): string;
+export declare function applyTextEdits(source: string, edits: TextEdit[], sorted?: boolean): string;

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

@@ -1,3 +1,4 @@
 export { renameTable } from './renameTable';
 export { applyTextEdits, type TextEdit } from './applyTextEdits';
 export { type TableNameInput } from './utils';
+export { syncDiagramView, findDiagramViewBlocks, type DiagramViewSyncOperation, type DiagramViewBlock } from './syncDiagramView';

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

@@ -0,0 +1,39 @@
+import { TextEdit } from './applyTextEdits';
+export interface DiagramViewSyncOperation {
+    operation: 'create' | 'update' | 'delete';
+    name: string;
+    newName?: string;
+    visibleEntities?: {
+        tables?: Array<{
+            name: string;
+            schemaName: string;
+        }> | null;
+        stickyNotes?: Array<{
+            name: string;
+        }> | null;
+        tableGroups?: Array<{
+            name: string;
+        }> | null;
+        schemas?: Array<{
+            name: string;
+        }> | null;
+    };
+}
+export interface DiagramViewBlock {
+    name: string;
+    startIndex: number;
+    endIndex: number;
+}
+export declare function findDiagramViewBlocks(source: string): DiagramViewBlock[];
+/**
+ * Synchronizes DiagramView blocks in DBML source code.
+ *
+ * @param dbml - The original DBML source code
+ * @param operations - Array of operations to apply (create, update, delete)
+ * @param blocks - Optional pre-parsed blocks from findDiagramViewBlocks. If not provided, parses internally.
+ * @returns Object containing the new DBML source code and the text edits applied
+ */
+export declare function syncDiagramView(dbml: string, operations: DiagramViewSyncOperation[], blocks?: DiagramViewBlock[]): {
+    newDbml: string;
+    edits: TextEdit[];
+};

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

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

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

@@ -0,0 +1,20 @@
+import { ElementDeclarationNode, ProgramNode } from '../../../parser/nodes';
+import { ElementBinder } from '../types';
+import { SyntaxToken } from '../../../lexer/tokens';
+import { CompileError } from '../../../errors';
+import { default as SymbolFactory } from '../../symbol/factory';
+export default class DiagramViewBinder implements ElementBinder {
+    private symbolFactory;
+    private declarationNode;
+    private ast;
+    constructor(declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    }, ast: ProgramNode, symbolFactory: SymbolFactory);
+    bind(): CompileError[];
+    private bindBody;
+    private bindSubElements;
+    private bindTableReferences;
+    private bindNoteReferences;
+    private bindTableGroupReferences;
+    private bindSchemaReferences;
+}

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

@@ -2,6 +2,7 @@ import { SyntaxToken } from '../../lexer/tokens';
 import { ElementDeclarationNode, PrimaryExpressionNode, ProgramNode, SyntaxNode, VariableNode } from '../../parser/nodes';
 import { default as ChecksBinder } from './elementBinder/checks';
 import { default as CustomBinder } from './elementBinder/custom';
+import { default as DiagramViewBinder } from './elementBinder/diagramView';
 import { default as EnumBinder } from './elementBinder/enum';
 import { default as IndexesBinder } from './elementBinder/indexes';
 import { default as NoteBinder } from './elementBinder/note';
@@ -15,7 +16,7 @@ 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 | typeof RecordsBinder | typeof DiagramViewBinder;
 export declare function scanNonListNodeForBinding(node?: SyntaxNode): {
     variables: (PrimaryExpressionNode & {
         expression: VariableNode;

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

@@ -10,7 +10,9 @@ export declare enum SymbolKind {
     EnumField = "Enum field",
     Note = "Note",
     TablePartial = "TablePartial",
-    PartialInjection = "PartialInjection"
+    PartialInjection = "PartialInjection",
+    DiagramView = "DiagramView",
+    DiagramViewField = "DiagramView field"
 }
 export declare function createSchemaSymbolIndex(key: string): NodeSymbolIndex;
 export declare function createTableSymbolIndex(key: string): NodeSymbolIndex;
@@ -22,6 +24,8 @@ export declare function createTableGroupFieldSymbolIndex(key: string): NodeSymbo
 export declare function createStickyNoteSymbolIndex(key: string): NodeSymbolIndex;
 export declare function createTablePartialSymbolIndex(key: string): NodeSymbolIndex;
 export declare function createPartialInjectionSymbolIndex(key: string): NodeSymbolIndex;
+export declare function createDiagramViewSymbolIndex(key: string): NodeSymbolIndex;
+export declare function createDiagramViewFieldSymbolIndex(key: string): NodeSymbolIndex;
 export declare function createNodeSymbolIndex(key: string, symbolKind: SymbolKind): NodeSymbolIndex;
 export declare function destructureIndex(id: NodeSymbolIndex): Option<{
     name: string;

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

@@ -74,6 +74,32 @@ export declare class TableGroupFieldSymbol implements NodeSymbol {
         declaration: SyntaxNode;
     }, id: NodeSymbolId);
 }
+export declare class DiagramViewSymbol implements NodeSymbol {
+    id: NodeSymbolId;
+    symbolTable: SymbolTable;
+    declaration: SyntaxNode;
+    references: SyntaxNode[];
+    constructor({ symbolTable, declaration }: {
+        symbolTable: SymbolTable;
+        declaration: SyntaxNode;
+    }, id: NodeSymbolId);
+}
+export declare class DiagramViewFieldSymbol implements NodeSymbol {
+    id: NodeSymbolId;
+    declaration: SyntaxNode;
+    references: SyntaxNode[];
+    constructor({ declaration }: {
+        declaration: SyntaxNode;
+    }, id: NodeSymbolId);
+}
+export declare class StickyNoteSymbol implements NodeSymbol {
+    id: NodeSymbolId;
+    declaration: SyntaxNode;
+    references: SyntaxNode[];
+    constructor({ declaration }: {
+        declaration: SyntaxNode;
+    }, id: NodeSymbolId);
+}
 export declare class TablePartialSymbol implements NodeSymbol {
     id: NodeSymbolId;
     symbolTable: SymbolTable;

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

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

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

@@ -1,5 +1,5 @@
 import { default as SymbolFactory } from '../../symbol/factory';
-import { CompileError } from '../../../errors';
+import { CompileError, CompileWarning } from '../../../errors';
 import { ElementDeclarationNode } from '../../../parser/nodes';
 import { SyntaxToken } from '../../../lexer/tokens';
 import { ElementValidator } from '../types';
@@ -11,7 +11,10 @@ export default class ChecksValidator implements ElementValidator {
     constructor(declarationNode: ElementDeclarationNode & {
         type: SyntaxToken;
     }, publicSymbolTable: SymbolTable, symbolFactory: SymbolFactory);
-    validate(): CompileError[];
+    validate(): {
+        errors: CompileError[];
+        warnings: CompileWarning[];
+    };
     private validateContext;
     private validateName;
     private validateAlias;

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

@@ -1,4 +1,4 @@
-import { CompileError } from '../../../errors';
+import { CompileError, CompileWarning } from '../../../errors';
 import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode } from '../../../parser/nodes';
 import { default as SymbolFactory } from '../../symbol/factory';
 import { SyntaxToken } from '../../../lexer/tokens';
@@ -11,7 +11,10 @@ export default class CustomValidator implements ElementValidator {
     constructor(declarationNode: ElementDeclarationNode & {
         type: SyntaxToken;
     }, publicSymbolTable: SymbolTable, symbolFactory: SymbolFactory);
-    validate(): CompileError[];
+    validate(): {
+        errors: CompileError[];
+        warnings: CompileWarning[];
+    };
     private validateContext;
     private validateName;
     private validateAlias;

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

@@ -0,0 +1,31 @@
+import { CompileError, CompileWarning } from '../../../errors';
+import { ElementValidator } from '../types';
+import { default as SymbolTable } from '../../symbol/symbolTable';
+import { SyntaxToken } from '../../../lexer/tokens';
+import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode } from '../../../parser/nodes';
+import { default as SymbolFactory } from '../../symbol/factory';
+export default class DiagramViewValidator implements ElementValidator {
+    private declarationNode;
+    private publicSymbolTable;
+    private symbolFactory;
+    constructor(declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    }, publicSymbolTable: SymbolTable, symbolFactory: SymbolFactory);
+    validate(): {
+        errors: CompileError[];
+        warnings: CompileWarning[];
+    };
+    private validateContext;
+    private validateName;
+    private validateAlias;
+    registerElement(): CompileError[];
+    private validateSettingList;
+    validateBody(body?: FunctionApplicationNode | BlockExpressionNode): {
+        errors: CompileError[];
+        warnings: CompileWarning[];
+    };
+    validateFields(fields: FunctionApplicationNode[]): CompileError[];
+    private validateSubElements;
+    private validateSubBlock;
+    registerSubBlockFields(sub: ElementDeclarationNode): CompileError[];
+}

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

@@ -1,5 +1,5 @@
 import { default as SymbolFactory } from '../../symbol/factory';
-import { CompileError } from '../../../errors';
+import { CompileError, CompileWarning } from '../../../errors';
 import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode, ListExpressionNode } from '../../../parser/nodes';
 import { SyntaxToken } from '../../../lexer/tokens';
 import { ElementValidator } from '../types';
@@ -11,7 +11,10 @@ export default class EnumValidator implements ElementValidator {
     constructor(declarationNode: ElementDeclarationNode & {
         type: SyntaxToken;
     }, publicSymbolTable: SymbolTable, symbolFactory: SymbolFactory);
-    validate(): CompileError[];
+    validate(): {
+        errors: CompileError[];
+        warnings: CompileWarning[];
+    };
     private validateContext;
     private validateName;
     private validateAlias;

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

@@ -1,5 +1,5 @@
 import { default as SymbolFactory } from '../../symbol/factory';
-import { CompileError } from '../../../errors';
+import { CompileError, CompileWarning } from '../../../errors';
 import { ElementDeclarationNode, SyntaxNode } from '../../../parser/nodes';
 import { SyntaxToken } from '../../../lexer/tokens';
 import { ElementValidator } from '../types';
@@ -11,7 +11,10 @@ export default class IndexesValidator implements ElementValidator {
     constructor(declarationNode: ElementDeclarationNode & {
         type: SyntaxToken;
     }, publicSymbolTable: SymbolTable, symbolFactory: SymbolFactory);
-    validate(): CompileError[];
+    validate(): {
+        errors: CompileError[];
+        warnings: CompileWarning[];
+    };
     private validateContext;
     private validateName;
     private validateAlias;

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

@@ -1,5 +1,5 @@
 import { default as SymbolFactory } from '../../symbol/factory';
-import { CompileError } from '../../../errors';
+import { CompileError, CompileWarning } from '../../../errors';
 import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode } from '../../../parser/nodes';
 import { SyntaxToken } from '../../../lexer/tokens';
 import { ElementValidator } from '../types';
@@ -11,7 +11,10 @@ export default class NoteValidator implements ElementValidator {
     constructor(declarationNode: ElementDeclarationNode & {
         type: SyntaxToken;
     }, publicSymbolTable: SymbolTable, symbolFactory: SymbolFactory);
-    validate(): CompileError[];
+    validate(): {
+        errors: CompileError[];
+        warnings: CompileWarning[];
+    };
     private validateContext;
     private validateName;
     private validateAlias;

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

@@ -1,5 +1,5 @@
 import { default as SymbolFactory } from '../../symbol/factory';
-import { CompileError } from '../../../errors';
+import { CompileError, CompileWarning } from '../../../errors';
 import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode } from '../../../parser/nodes';
 import { SyntaxToken } from '../../../lexer/tokens';
 import { ElementValidator } from '../types';
@@ -11,7 +11,10 @@ export default class ProjectValidator implements ElementValidator {
     constructor(declarationNode: ElementDeclarationNode & {
         type: SyntaxToken;
     }, publicSymbolTable: SymbolTable, symbolFactory: SymbolFactory);
-    validate(): CompileError[];
+    validate(): {
+        errors: CompileError[];
+        warnings: CompileWarning[];
+    };
     private validateContext;
     private validateName;
     private validateAlias;

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

@@ -1,5 +1,5 @@
 import { default as SymbolFactory } from '../../symbol/factory';
-import { CompileError } from '../../../errors';
+import { CompileError, CompileWarning } from '../../../errors';
 import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode } from '../../../parser/nodes';
 import { SyntaxToken } from '../../../lexer/tokens';
 import { ElementValidator } from '../types';
@@ -11,7 +11,10 @@ export default class RecordsValidator implements ElementValidator {
     constructor(declarationNode: ElementDeclarationNode & {
         type: SyntaxToken;
     }, publicSymbolTable: SymbolTable, symbolFactory: SymbolFactory);
-    validate(): CompileError[];
+    validate(): {
+        errors: CompileError[];
+        warnings: CompileWarning[];
+    };
     private validateContext;
     private validateName;
     private validateTopLevelName;

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

@@ -1,6 +1,6 @@
 import { SyntaxToken } from '../../../lexer/tokens';
 import { default as SymbolFactory } from '../../symbol/factory';
-import { CompileError } from '../../../errors';
+import { CompileError, CompileWarning } from '../../../errors';
 import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode, ListExpressionNode } from '../../../parser/nodes';
 import { ElementValidator } from '../types';
 import { default as SymbolTable } from '../../symbol/symbolTable';
@@ -11,7 +11,10 @@ export default class RefValidator implements ElementValidator {
     constructor(declarationNode: ElementDeclarationNode & {
         type: SyntaxToken;
     }, publicSymbolTable: SymbolTable, symbolFactory: SymbolFactory);
-    validate(): CompileError[];
+    validate(): {
+        errors: CompileError[];
+        warnings: CompileWarning[];
+    };
     private validateContext;
     private validateName;
     private validateAlias;

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

@@ -1,5 +1,5 @@
 import { default as SymbolFactory } from '../../symbol/factory';
-import { CompileError } from '../../../errors';
+import { CompileError, CompileWarning } from '../../../errors';
 import { BlockExpressionNode, ElementDeclarationNode, ExpressionNode, FunctionApplicationNode } from '../../../parser/nodes';
 import { ElementValidator } from '../types';
 import { SyntaxToken } from '../../../lexer/tokens';
@@ -11,7 +11,10 @@ export default class TableValidator implements ElementValidator {
     constructor(declarationNode: ElementDeclarationNode & {
         type: SyntaxToken;
     }, publicSymbolTable: SymbolTable, symbolFactory: SymbolFactory);
-    validate(): CompileError[];
+    validate(): {
+        errors: CompileError[];
+        warnings: CompileWarning[];
+    };
     private validateContext;
     private validateName;
     private validateAlias;

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

@@ -1,4 +1,4 @@
-import { CompileError } from '../../../errors';
+import { CompileError, CompileWarning } from '../../../errors';
 import { ElementValidator } from '../types';
 import { default as SymbolTable } from '../../symbol/symbolTable';
 import { SyntaxToken } from '../../../lexer/tokens';
@@ -11,7 +11,10 @@ export default class TableGroupValidator implements ElementValidator {
     constructor(declarationNode: ElementDeclarationNode & {
         type: SyntaxToken;
     }, publicSymbolTable: SymbolTable, symbolFactory: SymbolFactory);
-    validate(): CompileError[];
+    validate(): {
+        errors: CompileError[];
+        warnings: CompileWarning[];
+    };
     private validateContext;
     private validateName;
     private validateAlias;

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

@@ -1,5 +1,5 @@
 import { default as SymbolFactory } from '../../symbol/factory';
-import { CompileError } from '../../../errors';
+import { CompileError, CompileWarning } from '../../../errors';
 import { BlockExpressionNode, ElementDeclarationNode, ExpressionNode, FunctionApplicationNode } from '../../../parser/nodes';
 import { ElementValidator } from '../types';
 import { SyntaxToken } from '../../../lexer/tokens';
@@ -11,7 +11,10 @@ export default class TablePartialValidator implements ElementValidator {
     constructor(declarationNode: ElementDeclarationNode & {
         type: SyntaxToken;
     }, publicSymbolTable: SymbolTable, symbolFactory: SymbolFactory);
-    validate(): CompileError[];
+    validate(): {
+        errors: CompileError[];
+        warnings: CompileWarning[];
+    };
     private validateContext;
     private validateName;
     private validateAlias;

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

@@ -1,4 +1,7 @@
-import { CompileError } from '../../errors';
+import { CompileError, CompileWarning } from '../../errors';
 export interface ElementValidator {
-    validate(): CompileError[];
+    validate(): {
+        errors: CompileError[];
+        warnings: CompileWarning[];
+    };
 }

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

@@ -14,9 +14,10 @@ import { default as Report } from '../../report';
 import { default as TablePartialValidator } from './elementValidators/tablePartial';
 import { default as ChecksValidator } from './elementValidators/checks';
 import { default as RecordsValidator } from './elementValidators/records';
+import { default as DiagramViewValidator } from './elementValidators/diagramView';
 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 | typeof RecordsValidator | typeof DiagramViewValidator;
 export declare function isValidName(nameNode: SyntaxNode): boolean;
 export declare function isValidAlias(aliasNode: SyntaxNode): aliasNode is PrimaryExpressionNode & {
     expression: VariableNode;

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

@@ -95,6 +95,10 @@ export declare enum CompileErrorCode {
     INVALID_RECORDS_FIELD = 3079,
     DUPLICATE_COLUMN_REFERENCES_IN_RECORDS = 3080,
     DUPLICATE_RECORDS_FOR_TABLE = 3081,
+    INVALID_DIAGRAMVIEW_CONTEXT = 3082,
+    DUPLICATE_DIAGRAMVIEW_NAME = 3083,
+    INVALID_DIAGRAMVIEW_FIELD = 3084,
+    DUPLICATE_DIAGRAMVIEW_FIELD = 3085,
     BINDING_ERROR = 4000,
     UNSUPPORTED = 5000,
     CIRCULAR_REF = 5001,

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

@@ -0,0 +1,13 @@
+import { CompileError } from '../../errors';
+import { ElementDeclarationNode } from '../../parser/nodes';
+import { ElementInterpreter, InterpreterDatabase } from '../types';
+export declare class DiagramViewInterpreter implements ElementInterpreter {
+    private declarationNode;
+    private env;
+    private diagramView;
+    constructor(declarationNode: ElementDeclarationNode, env: InterpreterDatabase);
+    interpret(): CompileError[];
+    private interpretName;
+    private interpretBody;
+    private interpretSubBlock;
+}