@dbml/parse 6.4.0 → 7.0.0-alpha.0

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

@@ -0,0 +1,30 @@
+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;
+    };
+}
+/**
+ * Synchronizes DiagramView blocks in DBML source code.
+ *
+ * @param dbml - The original DBML source code
+ * @param operations - Array of operations to apply (create, update, delete)
+ * @returns Object containing the new DBML source code
+ */
+export declare function syncDiagramView(dbml: string, operations: DiagramViewSyncOperation[]): {
+    newDbml: string;
+};

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/diagramView.d.ts

@@ -0,0 +1,25 @@
+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(): CompileError[];
+    private validateContext;
+    private validateName;
+    private validateAlias;
+    registerElement(): CompileError[];
+    private validateSettingList;
+    validateBody(body?: FunctionApplicationNode | BlockExpressionNode): (CompileError | CompileWarning)[];
+    validateFields(fields: FunctionApplicationNode[]): (CompileError | CompileWarning)[];
+    private validateSubElements;
+    private validateSubBlock;
+    registerSubBlockFields(sub: ElementDeclarationNode): CompileError[];
+}

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;
+}

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

@@ -8,6 +8,37 @@ export interface TokenPosition {
 export interface ElementInterpreter {
     interpret(): CompileError[];
 }
+/**
+ * FilterConfig is a tri-state filter:
+ * - [] (empty array) = show all
+ * - [...] (array with items) = show only these specific items
+ * - null = hide all
+ */
+export interface FilterConfig {
+    tables: Array<{
+        name: string;
+        schemaName: string;
+    }> | null;
+    stickyNotes: Array<{
+        name: string;
+    }> | null;
+    tableGroups: Array<{
+        name: string;
+    }> | null;
+    schemas: Array<{
+        name: string;
+    }> | null;
+}
+export interface DiagramView {
+    name: string;
+    schemaName: string | null;
+    visibleEntities: FilterConfig;
+    token: TokenPosition;
+    /** Internal: tracks which dims used explicit wildcard (*). Stripped before output. */
+    _explicitWildcards?: Set<string>;
+    /** Internal: tracks which dims were explicitly declared in the DBML. Stripped before output. */
+    _explicitlySet?: Set<string>;
+}
 export interface InterpreterDatabase {
     schema: [];
     tables: Map<ElementDeclarationNode, Table>;
@@ -28,6 +59,7 @@ export interface InterpreterDatabase {
     recordsElements: ElementDeclarationNode[];
     cachedMergedTables: Map<Table, Table>;
     source: string;
+    diagramViews?: Map<ElementDeclarationNode, DiagramView>;
 }
 export type RecordValueType = 'string' | 'bool' | 'integer' | 'real' | 'date' | 'time' | 'datetime' | string;
 export interface RecordValue {
@@ -64,6 +96,7 @@ export interface Database {
     project: Project;
     tablePartials: TablePartial[];
     records: TableRecord[];
+    diagramViews: DiagramView[];
 }
 export interface Table {
     name: string;

package/dist/src/index.d.ts

@@ -7,5 +7,8 @@ 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 { type Database, type Table, type Column, type Enum, type Ref, type Project, type TableGroup, type TablePartial, } from './core/interpreter/types';
+export { type Database, type Table, type Column, type Enum, type Ref, type Project, type TableGroup, type TablePartial, type DiagramView, type FilterConfig, } from './core/interpreter/types';
+export { syncDiagramView } from './compiler/queries/transform/syncDiagramView';
+export type { DiagramViewSyncOperation } from './compiler/queries/transform/syncDiagramView';
+export { dbmlMonarchTokensProvider } from './services/monarch';
 export { Compiler, services };

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

@@ -4,3 +4,4 @@ import { default as DBMLReferencesProvider } from './references/provider';
 import { default as DBMLDiagnosticsProvider } from './diagnostics/provider';
 export * from './types';
 export { DBMLCompletionItemProvider, DBMLDefinitionProvider, DBMLReferencesProvider, DBMLDiagnosticsProvider, };
+export { dbmlMonarchTokensProvider } from './monarch';

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

@@ -0,0 +1,3 @@
+import { languages } from 'monaco-editor-core';
+declare const dbmlMonarchTokensProvider: languages.IMonarchLanguage;
+export { dbmlMonarchTokensProvider };

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@dbml/parse",
-  "version": "6.4.0",
+  "version": "7.0.0-alpha.0",
   "description": "DBML parser v2",
   "author": "Holistics <dev@holistics.io>",
   "license": "Apache-2.0",
@@ -30,7 +30,6 @@
     "test": "vitest run",
     "test:watch": "vitest watch",
     "coverage": "vitest run --coverage",
-    "prepublish": "npm run build",
     "prepare": "npm run build",
     "lint": "eslint .",
     "lint:fix": "eslint --fix ."
@@ -46,5 +45,5 @@
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "e365a1165ce3610f2bc9563b9eefac206d2f5c35"
+  "gitHead": "cb925c52bc255aa63688dc04db48f2ad5d7129c9"
 }