@dbml/parse 10.4.0-alpha.1 → 10.4.0-alpha.10

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

@@ -3,10 +3,11 @@ import { SyntaxNode, SyntaxNodeIdGenerator } from '../core/types/nodes';
 import { NodeSymbolIdGenerator, SymbolFactory } from '../core/types/symbol';
 import { DBMLCodeActionProvider, DBMLCompletionItemProvider, DBMLDefinitionProvider, DBMLDiagnosticsProvider, DBMLReferencesProvider } from '../services/index';
 import { DbmlProjectLayout } from './projectLayout';
-import { addDoubleQuoteIfNeeded, escapeString, formatRecordValue, isValidIdentifier, normalizeQualifiedName, splitQualifiedIdentifier, unescapeString } from './queries/utils';
+import { addDoubleQuoteIfNeeded, escapeString, formatTypedValue, isValidIdentifier, normalizeQualifiedName, splitQualifiedIdentifier, unescapeString, TypedValue } from './queries/utils';
 export { ScopeKind } from './types';
 export type { TextEdit } from './queries/transform';
-export { addDoubleQuoteIfNeeded, escapeString, formatRecordValue, isValidIdentifier, normalizeQualifiedName, splitQualifiedIdentifier, unescapeString, };
+export { addDoubleQuoteIfNeeded, escapeString, formatTypedValue, isValidIdentifier, normalizeQualifiedName, splitQualifiedIdentifier, unescapeString, };
+export type { TypedValue };
 export default class Compiler {
     layout: DbmlProjectLayout;
     readonly nodeIdGenerator: SyntaxNodeIdGenerator;
@@ -50,26 +51,7 @@ export default class Compiler {
     symbolMetadata: (symbol: import('../core/types/symbol').NodeSymbol) => import('../core/types/symbol').NodeMetadata[];
     symbolAliases: (symbol: import('../core/types/symbol').NodeSymbol) => import('../core/types/report').default<import('../core/types/symbol').AliasSymbol[]>;
     symbolUses: (symbol: import('../core/types/symbol').NodeSymbol) => import('../core/types/report').default<import('../core/types/symbol').UseSymbol[]>;
-    /**
-      * A global query
-      * Return the named refs visible from a program (refs are not imported via `use`).
-      */
-    visibleSymbols: (program: import('../core/types/symbol').ProgramSymbol, kind: import('../core/types/symbol').SymbolKind) => import('../core/types/symbol').RefSymbol[];
-    /**
-      * A global query
-      * Whether a symbol is visible from a program
-      */
-    isSymbolVisible: (program: import('../core/types/symbol').ProgramSymbol, symbol: import('../core/types/symbol').NodeSymbol) => boolean;
-    /**
-      * A global query
-      * Resolve all candidates that a metadata block can target
-      */
-    metadataTargets: (block: import('../core/types/symbol').MetadataElementMetadata) => import('../core/types/symbol').NodeSymbol[];
     fileDependencies: (filepath: Filepath) => Filepath[];
-    /**
-      * A global query
-      * BFS-traverse imports from an entry filepath and return all reachable files. Related: fileDependencies.
-      */
     reachableFiles: (entry?: Filepath | undefined) => Filepath[];
     usableMembers: (symbolOrFilepath: Filepath | import('../core/types/symbol').SchemaSymbol | import('../core/types/symbol').ProgramSymbol) => import('../core/types/report').default<{
         nonSchemaMembers: import('../core/types/symbol').NodeSymbol[];
@@ -93,6 +75,9 @@ export default class Compiler {
     renameTable: (filepath: Filepath, oldName: string | import('..').TableIdentifier, newName: string | import('..').TableIdentifier) => Map<string, string>;
     updateElementSetting: (filepath: Filepath, target: import('..').ElementIdentifier, settingName: string, value: string | null | undefined) => string;
     updateElementSettingEdit: (filepath: Filepath, target: import('..').ElementIdentifier, settingName: string, value: string | null | undefined) => import('.').TextEdit[];
+    findMetadataBlock: (filepath: Filepath, target: import('..').ElementIdentifier) => import('../core/types/nodes').ElementDeclarationNode | undefined;
+    updateElementMetadata: (filepath: Filepath, target: import('..').ElementIdentifier, key: string, value: TypedValue) => string;
+    updateElementMetadataEdit: (filepath: Filepath, target: import('..').ElementIdentifier, key: string, value: TypedValue) => import('.').TextEdit[];
     syncDiagramView: (filepath: Filepath, operations: import('..').DiagramViewSyncOperation[], blocks?: import('..').DiagramViewBlock[] | undefined) => {
         newDbml: string;
         edits: import('.').TextEdit[];
@@ -109,7 +94,7 @@ export default class Compiler {
         source: (filepath: Filepath) => string;
         ast: (filepath?: Filepath) => Readonly<import('../core/types/nodes').ProgramNode>;
         errors: (filepath?: Filepath) => readonly Readonly<import('..').CompileError>[];
-        warnings: (filepath?: Filepath) => readonly Readonly<import('../core/types').CompileWarning>[];
+        warnings: (filepath?: Filepath) => readonly Readonly<import('..').CompileWarning>[];
         tokens: (filepath?: Filepath) => readonly Readonly<import('..').SyntaxToken>[];
         rawDb: (filepath?: Filepath) => Readonly<import('..').Database> | undefined;
         publicSymbolTable: (filepath?: Filepath) => readonly Readonly<import('../core/types/symbol').NodeSymbol>[] | undefined;
@@ -130,6 +115,7 @@ export default class Compiler {
     initMonacoServices(options?: {
         autocompletion?: {
             triggerCharacters?: string[];
+            fileListDepth?: number;
         };
     }): {
         definitionProvider: DBMLDefinitionProvider;

package/dist/src/compiler/projectLayout/layout.d.ts

@@ -1,6 +1,12 @@
 import { Filepath } from '../../core/types/filepath';
+export interface FileSpecifierInfo {
+    specifier: string;
+    label?: string;
+    detail?: string;
+}
 export interface DbmlProjectLayout {
     resolveFileSpecifier(currentFilepath: Filepath, specifier: string): Filepath | undefined;
+    getFileSpecifierInfo(currentFilepath: Filepath, targetFilepath: Filepath): FileSpecifierInfo | undefined;
     getSource(filePath: Filepath): string | undefined;
     exists(filePath: Filepath): boolean;
     isFile(filePath: Filepath): boolean;
@@ -12,6 +18,7 @@ export declare class MemoryProjectLayout implements DbmlProjectLayout {
     private readonly files;
     constructor(files?: Map<string, string> | Record<string, string>);
     resolveFileSpecifier(currentFilepath: Filepath, relativePath: string): Filepath | undefined;
+    getFileSpecifierInfo(currentFilepath: Filepath, targetFilepath: Filepath): FileSpecifierInfo | undefined;
     setSource(filePath: Filepath, content: string): void;
     getSource(filePath: Filepath): string | undefined;
     deleteSource(filePath: Filepath): void;

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

@@ -1,5 +1,6 @@
 export { renameTable } from './renameTable';
 export { updateElementSetting, updateElementSettingEdit } from './updateElementSetting';
+export { findMetadataBlock, updateElementMetadata, updateElementMetadataEdit } from './updateElementMetadata';
 export { syncDiagramView, findDiagramViewBlocks, type DiagramViewSyncOperation, type DiagramViewBlock, } from './syncDiagramView';
 export { syncDep, generateDepBlock, type DepSyncOperation, type DepSyncEdge, type DepEndpointRef, } from './syncDep';
 export { applyTextEdits, type TextEdit } from './applyTextEdits';

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

@@ -0,0 +1,9 @@
+import { Filepath } from '../../../core/types/filepath';
+import { ElementDeclarationNode } from '../../../core/types/nodes';
+import { default as Compiler } from '../../index';
+import { TextEdit } from './applyTextEdits';
+import { ElementIdentifier } from './types';
+import { TypedValue } from '../utils';
+export declare function findMetadataBlock(this: Compiler, filepath: Filepath, target: ElementIdentifier): ElementDeclarationNode | undefined;
+export declare function updateElementMetadataEdit(this: Compiler, filepath: Filepath, target: ElementIdentifier, key: string, value: TypedValue | null): TextEdit[];
+export declare function updateElementMetadata(this: Compiler, filepath: Filepath, target: ElementIdentifier, key: string, value: TypedValue | null): string;

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

@@ -70,20 +70,21 @@ export declare function escapeString(str: string): string;
  * @returns The formatted string representation for DBML
  *
  * @example
- * formatRecordValue({ value: 1, type: 'integer' }) => '1'
- * formatRecordValue({ value: 'Alice', type: 'string' }) => "'Alice'"
- * formatRecordValue({ value: true, type: 'bool' }) => 'true'
- * formatRecordValue({ value: null, type: 'string' }) => 'null'
- * formatRecordValue(undefined) => 'null'
- * formatRecordValue(null) => 'null'
- * formatRecordValue('Alice') => "'Alice'"
- * formatRecordValue(42) => '42'
- * formatRecordValue(true) => 'true'
+ * formatTypedValue({ value: 1, type: 'integer' }) => '1'
+ * formatTypedValue({ value: 'Alice', type: 'string' }) => "'Alice'"
+ * formatTypedValue({ value: true, type: 'bool' }) => 'true'
+ * formatTypedValue({ value: null, type: 'string' }) => 'null'
+ * formatTypedValue(undefined) => 'null'
+ * formatTypedValue(null) => 'null'
+ * formatTypedValue('Alice') => "'Alice'"
+ * formatTypedValue(42) => '42'
+ * formatTypedValue(true) => 'true'
  */
-export declare function formatRecordValue(recordValue: {
+export type TypedValue = {
     value: any;
     type: string;
-} | string | number | boolean | null | undefined): string;
+} | string | number | boolean | null | undefined;
+export declare function formatTypedValue(recordValue: TypedValue): string;
 /**
  * Splits a qualified identifier string into its components, handling quoted segments.
  *

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

@@ -1,9 +1,9 @@
 import { default as Compiler } from '../../../compiler/index';
 import { Filepath, SettingName } from '../../types';
-import { Column, Note, Ref, Table, TableGroup, TokenPosition } from '../../types/schemaJson';
-import { SyntaxNode } from '../../types/nodes';
+import { Column, Note, Table, TableGroup, TokenPosition } from '../../types/schemaJson';
+import { ElementDeclarationNode, SyntaxNode } from '../../types/nodes';
 import { NodeSymbol, SymbolKind, MetadataTargetKind } from '../../types/symbol';
-export type MetadataTarget = Table | TableGroup | Note | Column | Ref;
+export type MetadataTarget = Table | TableGroup | Note | Column;
 /**
   * Specs for builtin metadata (table's note, tablegroup's color, .etc) for different element types. Does 2 things:
   * - `validate`: Validating if the metadata value is syntactically correct
@@ -17,15 +17,13 @@ interface MetadataField<T extends MetadataTarget> {
     assignBuiltinField(element: Partial<T>, value: string, token: TokenPosition): void;
 }
 export type MetadataFieldRegistry<T extends MetadataTarget, K extends SettingName = SettingName> = Record<K, MetadataField<T>>;
-export type NameWithSymbolKind = {
+type NameWithSymbolKind = {
     name: string;
     symbolKind: SymbolKind;
 };
 /** @internal Exported for testing only. */
-export declare function mapNamePartToSymbolKind(nameParts: string[], targetKind: Exclude<MetadataTargetKind, MetadataTargetKind.Ref>): NameWithSymbolKind[];
-/**
-  * Merge every custom-metadata block applying to the target in the current program (in precedence order) to its `metadata` and other builtin (note/headercolor/...) fields
-  * NOTE: Only run during interpret phase
-  */
+export declare function mapNamePartToSymbolKind(nameParts: string[], targetKind: MetadataTargetKind): NameWithSymbolKind[];
+export declare function resolveMetadataTarget(compiler: Compiler, metadataNode: ElementDeclarationNode): NodeSymbol | undefined;
+/** Merge every custom-metadata block, reachable from the current program, targeting element to it's `metadata` and other builtin (note/headercolor/...) fields */
 export declare function attachCustomMetadata<T extends MetadataTarget>(compiler: Compiler, targetElement: Partial<T>, targetSymbol: NodeSymbol, fieldsRegistry: MetadataFieldRegistry<T, any>, filepath: Filepath): void;
 export {};

package/dist/src/core/global_modules/ref/index.d.ts

@@ -2,10 +2,6 @@ import { default as Compiler } from '../../../compiler/index';
 import { SyntaxNode } from '../../types/nodes';
 import { default as Report } from '../../types/report';
 import { NodeSymbol } from '../../types/symbol';
-import { CompileError } from '../../types';
 import { GlobalModule } from '../types';
-export declare const refUtils: {
-    getDuplicateError(name: string, schemaLabel: string, errorNode: SyntaxNode): CompileError;
-};
 export declare const refModule: GlobalModule;
 export declare function nodeRefereeOfRefEndpoint(compiler: Compiler, globalSymbol: NodeSymbol, node: SyntaxNode): Report<NodeSymbol | undefined>;

package/dist/src/core/global_modules/ref/interpret.d.ts

@@ -1,9 +1,7 @@
 import { Ref } from '../../types/schemaJson';
-import { RefMetadata, SettingName, Filepath } from '../../types';
+import { RefMetadata, Filepath } from '../../types';
 import { default as Compiler } from '../../../compiler';
 import { default as Report } from '../../types/report';
-import { MetadataFieldRegistry } from '../metadata/utils';
-export declare const REF_METADATA_FIELDS: MetadataFieldRegistry<Ref, SettingName.Color | SettingName.Note>;
 export declare class RefInterpreter {
     private compiler;
     private metadata;

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

@@ -5,10 +5,12 @@ export type FilepathId = string & {
 };
 export declare class Filepath implements Internable<FilepathId> {
     private readonly protocol?;
-    private readonly path;
+    private readonly root;
+    private readonly segments;
     constructor(absolutePath: string, options?: {
         protocol?: string;
     });
+    private get path();
     intern(): FilepathId;
     static from(absolutePath: string): Filepath;
     static resolve(fromDir: string, relativePath: string): Filepath;

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

@@ -164,14 +164,9 @@ export interface Ref {
     name: string | null;
     endpoints: RefEndpointPair;
     color?: Color;
-    note?: {
-        value: string;
-        token: TokenPosition;
-    };
     onDelete?: string;
     onUpdate?: string;
     inactive?: boolean;
-    metadata?: CustomMetadata;
     token: TokenPosition;
 }
 export type RefEndpointPair = [RefEndpoint, RefEndpoint];

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

@@ -16,7 +16,6 @@ export declare enum SymbolKind {
     Enum = "Enum",
     EnumField = "Enum field",
     StickyNote = "Note",
-    Ref = "Ref",
     TablePartial = "TablePartial",
     PartialInjection = "PartialInjection",
     DiagramView = "DiagramView",
@@ -42,8 +41,7 @@ export declare enum MetadataTargetKind {
     Table = "Table",
     Column = "Column",
     TableGroup = "TableGroup",
-    Note = "Note",
-    Ref = "Ref"
+    Note = "Note"
 }
 declare const __nodeSymbolBrand: unique symbol;
 export type NodeSymbolId = number & {
@@ -213,14 +211,6 @@ export declare class NoteSymbol extends NodeSymbol {
     get canBeImported(): boolean;
     get originalSymbol(): NodeSymbol;
 }
-export declare class RefSymbol extends NodeSymbol {
-    constructor({ declaration, name, }: {
-        declaration?: SyntaxNode;
-        name?: string;
-    }, id: NodeSymbolId, filepath: Filepath);
-    get canBeImported(): boolean;
-    get originalSymbol(): NodeSymbol;
-}
 export declare class TablePartialSymbol extends NodeSymbol {
     constructor({ declaration, name, }: {
         declaration?: SyntaxNode;

package/dist/src/index.d.ts

@@ -8,9 +8,10 @@ export { MetadataKind } from './core/types/symbol/metadata';
 export * from './core/global_modules/records/utils';
 export * from './core/types/nodes';
 export { SyntaxToken, SyntaxTokenKind, isTriviaToken, isOp, isOpToken, } from './core/types/tokens';
-export { CompileError, CompileErrorCode, } from './core/types/errors';
+export { CompileError, CompileErrorCode, CompileWarning, CompileInfo, } from './core/types/errors';
+export type { Diagnostic, DiagnosticQuickFix } from './services/diagnostics/provider';
 export type { Position, } from './core/types';
-export { ScopeKind, splitQualifiedIdentifier, unescapeString, escapeString, formatRecordValue, isValidIdentifier, addDoubleQuoteIfNeeded, normalizeQualifiedName, } from './compiler/index';
+export { ScopeKind, splitQualifiedIdentifier, unescapeString, escapeString, formatTypedValue, type TypedValue, isValidIdentifier, addDoubleQuoteIfNeeded, normalizeQualifiedName, } from './compiler/index';
 export { type Database, type MasterDatabase, type Table, type Note, type Column, type ColumnType, type Index, type Check, type InlineRef, type Ref, type RefEndpointPair, type RefEndpoint, type Enum, type EnumField, type TableGroup, type TableGroupField, type Alias, type AliasKind, type TablePartial, type TablePartialInjection, type RecordValue, type RecordValueType, type TableRecord, type Project, type SchemaElement, type TokenPosition, type ElementRef, type FilterConfig, type DiagramView, type CustomMetadata, } from './core/types/schemaJson';
 export { type RelationCardinality, type RelationshipOp, getRelationshipOp, getMultiplicities, parseCardinality, makeCardinalityRequired, makeCardinalityOptional, makeRelationshipRequired, isEndpointOneSide, isEndpointManySide, isEndpointOptional, isEndpointRequired, CARDINALITY_ONE, CARDINALITY_MAYBE, CARDINALITY_SOME, CARDINALITY_MANY, } from './core/types/relation';
 export type { DiagramViewSyncOperation, DiagramViewBlock, TextEdit, } from './compiler/queries/transform';

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

@@ -4,4 +4,5 @@ export default class DBMLDefinitionProvider implements DefinitionProvider {
     private compiler;
     constructor(compiler: Compiler);
     provideDefinition(model: TextModel, position: Position): Definition;
+    private resolveImportPath;
 }

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

@@ -20,11 +20,13 @@ export declare const TABLE_BODY_SUGGESTION_LABELS: ("indexes" | "checks" | "Note
 export declare const PROJECT_FIELD_SUGGESTION_LABELS: ("Table" | "Enum" | "TableGroup" | "TablePartial" | "Note" | "Ref" | "Dep")[];
 export interface DBMLCompletionItemProviderOptions {
     triggerCharacters?: string[];
+    fileListDepth?: number;
 }
 export default class DBMLCompletionItemProvider implements CompletionItemProvider {
     private compiler;
     triggerCharacters: string[];
+    fileListDepth: number;
     constructor(compiler: Compiler, options?: DBMLCompletionItemProviderOptions);
     provideCompletionItems(model: TextModel, position: Position): CompletionList;
 }
-export declare const TOP_LEVEL_SUGGESTION_LABELS: ("Table" | "Enum" | "TableGroup" | "TablePartial" | "Note" | "Ref" | "DiagramView" | "Metadata" | "Dep" | "Project" | "Records")[];
+export declare const TOP_LEVEL_SUGGESTION_LABELS: ("Table" | "Enum" | "TableGroup" | "TablePartial" | "Note" | "DiagramView" | "Metadata" | "Ref" | "Dep" | "Project" | "Records")[];

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

@@ -2,4 +2,7 @@ import { default as Compiler } from '../../compiler';
 import { Filepath } from '../../core/types/filepath';
 import { SyntaxToken } from '../../core/types/tokens';
 import { CompletionList, TextModel } from '../types';
-export declare function suggestUseCompletion(compiler: Compiler, filepath: Filepath, offset: number, bOcToken: SyntaxToken | undefined, model: TextModel): CompletionList | null;
+export interface SuggestUseCompletionOptions {
+    fileListDepth?: number;
+}
+export declare function suggestUseCompletion(compiler: Compiler, filepath: Filepath, offset: number, bOcToken: SyntaxToken | undefined, model: TextModel, options?: SuggestUseCompletionOptions): CompletionList | null;

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@dbml/parse",
-  "version": "10.4.0-alpha.1",
+  "version": "10.4.0-alpha.10",
   "description": "DBML parser v2",
   "author": "Holistics <dev@holistics.io>",
   "license": "Apache-2.0",
@@ -25,7 +25,7 @@
     "dist"
   ],
   "scripts": {
-    "build": "rm -rf ./dist && tsc --noEmit && vite build",
+    "build": "rimraf ./dist && tsc --noEmit && vite build",
     "dev": "vite build --watch",
     "test": "vitest run",
     "test:watch": "vitest watch",
@@ -51,5 +51,5 @@
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "2abacb40597047ca589b2c18117f57f8fe3978e6"
+  "gitHead": "803873f5165a628d3f9050b9dff0173adab072b2"
 }

package/dist/src/compiler/queries/metadata/isSymbolVisible.d.ts

@@ -1,10 +0,0 @@
-import { NodeSymbol, ProgramSymbol } from '../../../core/types/symbol';
-import { default as Compiler } from '../../index';
-/**
-  * Whether `symbol` is visible from `program`.
-  * - Column: visible when its table is (a column is not a direct schema member)
-  * - Ref: refs are not imported via `use`, a ref is visible when it shows up in the program's output,
-  *   i.e. the program reaches the ref's file and sees both endpoint tables (RefMetadata.owners)
-  * - otherwise: the symbol sits in the program's schemas, directly or through `use`
-  */
-export declare function isSymbolVisible(this: Compiler, program: ProgramSymbol, symbol: NodeSymbol): boolean;

package/dist/src/compiler/queries/metadata/metadataTargets.d.ts

@@ -1,7 +0,0 @@
-import { NodeSymbol } from '../../../core/types/symbol';
-import { MetadataElementMetadata } from '../../../core/types/symbol/metadata';
-import { default as Compiler } from '../../index';
-/**
-  * Resolve the candidates a Metadata block targets, from its `<target-kind> <name>` header.
-  */
-export declare function metadataTargets(this: Compiler, block: MetadataElementMetadata): NodeSymbol[];

package/dist/src/compiler/queries/symbol/visibleSymbols.d.ts

@@ -1,7 +0,0 @@
-import { ProgramSymbol, RefSymbol, SymbolKind } from '../../../core/types/symbol';
-import { default as Compiler } from '../../index';
-/**
-  * Named refs usable from `program`: refs are not imported via `use`, a named ref is visible
-  * wherever it shows up in the output (see isSymbolVisible).
-  */
-export declare function visibleSymbols(this: Compiler, program: ProgramSymbol, kind: SymbolKind): RefSymbol[];