@dbml/parse 9.1.1 → 9.1.2-alpha.0

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

@@ -3,11 +3,10 @@ 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 { DiagramViewBlock, findDiagramViewBlocks } from './queries/transform';
-import { addDoubleQuoteIfNeeded, escapeString, formatRecordValue, isValidIdentifier, splitQualifiedIdentifier, unescapeString } from './queries/utils';
+import { addDoubleQuoteIfNeeded, escapeString, formatRecordValue, isValidIdentifier, normalizeQualifiedName, splitQualifiedIdentifier, unescapeString } from './queries/utils';
 export { ScopeKind } from './types';
-export type { DiagramViewBlock, TableNameInput, TextEdit } from './queries/transform';
-export { addDoubleQuoteIfNeeded, escapeString, formatRecordValue, isValidIdentifier, splitQualifiedIdentifier, unescapeString, findDiagramViewBlocks, };
+export type { TextEdit } from './queries/transform';
+export { addDoubleQuoteIfNeeded, escapeString, formatRecordValue, isValidIdentifier, normalizeQualifiedName, splitQualifiedIdentifier, unescapeString, };
 export default class Compiler {
     layout: DbmlProjectLayout;
     readonly nodeIdGenerator: SyntaxNodeIdGenerator;
@@ -72,12 +71,17 @@ export default class Compiler {
         };
     }>;
     nodeAtPosition: (filepath: Filepath, offset: number) => SyntaxNode | import('..').SyntaxToken | undefined;
-    renameTable: (filepath: Filepath, oldName: import('.').TableNameInput, newName: import('.').TableNameInput) => Map<string, string>;
-    syncDiagramView: (filepath: Filepath, operations: import('..').DiagramViewSyncOperation[], blocks?: DiagramViewBlock[] | undefined) => {
+    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[];
+    syncDiagramView: (filepath: Filepath, operations: import('..').DiagramViewSyncOperation[], blocks?: import('..').DiagramViewBlock[] | undefined) => {
+        newDbml: string;
+        edits: import('.').TextEdit[];
+    };
+    syncDep: (filepath: Filepath, operations: import('..').DepSyncOperation[], blocks?: import('..').DepBlock[] | undefined) => {
         newDbml: string;
         edits: import('.').TextEdit[];
     };
-    findDiagramViewBlocks(filepath: Filepath): DiagramViewBlock[];
     readonly token: {
         invalidStream: (filepath: Filepath) => readonly import('..').SyntaxToken[];
         flatStream: (filepath: Filepath) => readonly import('..').SyntaxToken[];

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

@@ -1,4 +1,6 @@
 export { renameTable } from './renameTable';
+export { updateElementSetting, updateElementSettingEdit } from './updateElementSetting';
 export { syncDiagramView, findDiagramViewBlocks, type DiagramViewSyncOperation, type DiagramViewBlock, } from './syncDiagramView';
+export { syncDep, findDepBlocks, generateDepBlock, type DepSyncOperation, type DepSyncEdge, type DepEndpointRef, type DepBlock, } from './syncDep';
 export { applyTextEdits, type TextEdit } from './applyTextEdits';
-export { type TableNameInput } from './utils';
+export type { ElementIdentifier, SchemaIdentifier, TableIdentifier, ColumnIdentifier, EnumIdentifier, EndpointRef, RefIdentifier, DepIdentifier, NoteIdentifier, TableGroupIdentifier, } from './types';

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

@@ -1,6 +1,6 @@
 import { Filepath } from '../../../core/types/filepath';
 import { default as Compiler } from '../../index';
-import { TableNameInput } from './utils';
+import { TableIdentifier } from './types';
 /**
  * Renames a table across every file in the project layout.
  *
@@ -23,4 +23,4 @@ import { TableNameInput } from './utils';
  * only the files that were actually changed by the rename. An empty map
  * indicates a no-op (lookup miss, name collision, or alias rename attempt).
  */
-export declare function renameTable(this: Compiler, filepath: Filepath, oldName: TableNameInput, newName: TableNameInput): Map<string, string>;
+export declare function renameTable(this: Compiler, filepath: Filepath, oldName: string | TableIdentifier, newName: string | TableIdentifier): Map<string, string>;

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

@@ -0,0 +1,54 @@
+import { Filepath } from '../../../core/types/filepath';
+import { ElementDeclarationNode, ProgramNode } from '../../../core/types/nodes';
+import { default as Compiler } from '../../index';
+import { TextEdit } from './applyTextEdits';
+export interface DepEndpointRef {
+    schemaName?: string | null;
+    tableName: string;
+    fieldNames?: string[];
+}
+export interface DepSyncEdge {
+    upstream: DepEndpointRef;
+    downstream: DepEndpointRef;
+}
+export interface DepSyncOperation {
+    operation: 'create' | 'update' | 'remove';
+    /** The edge that identifies the target block (table-level: empty fields). */
+    edge: DepSyncEdge;
+    /** Set to a value to create/update, null to remove, undefined to leave unchanged. */
+    color?: string | null;
+    /** Set to a value to create/update, null to remove, undefined to leave unchanged. */
+    note?: string | null;
+}
+export interface DepBlock {
+    startIndex: number;
+    endIndex: number;
+    declaration: ElementDeclarationNode;
+    edges: DepSyncEdge[];
+}
+export interface InlineDep {
+    edge: DepSyncEdge;
+    fullStart: number;
+    fullEnd: number;
+}
+/**
+ * Synchronizes `Dep` blocks in the DBML source at `filepath`.
+ * Applies create/update/remove operations and returns the rewritten source.
+ */
+export declare function syncDep(this: Compiler, filepath: Filepath, operations: DepSyncOperation[], blocks?: DepBlock[]): {
+    newDbml: string;
+    edits: TextEdit[];
+};
+/**
+ * Returns every standalone `Dep` block in `source`.
+ * On lex/parse error returns [] (mirrors findDiagramViewBlocks).
+ */
+export declare function findDepBlocks(source: string): DepBlock[];
+/** Returns every inline `[dep: -> target]` setting on columns in `source`. */
+export declare function findInlineDeps(source: string): InlineDep[];
+/** Emit a `Dep` block string for one edge with a `[color]` setting. */
+export declare function generateDepBlock(edge: DepSyncEdge, color: string): string;
+/** Extract `DepBlock[]` from an already-parsed program AST. */
+export declare function depBlocksFromProgram(program: ProgramNode): DepBlock[];
+/** Extract `InlineDep[]` from an already-parsed program AST. */
+export declare function inlineDepsFromProgram(source: string, program: ProgramNode): InlineDep[];

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

@@ -0,0 +1,48 @@
+import { SymbolKind } from '../../../core/types/symbol';
+import { MetadataKind } from '../../../core/types/symbol/metadata';
+export type ElementIdentifier = (SchemaIdentifier | TableIdentifier | ColumnIdentifier | EnumIdentifier | RefIdentifier | DepIdentifier | NoteIdentifier | TableGroupIdentifier) & {
+    kind: string;
+};
+export interface SchemaIdentifier {
+    kind?: typeof SymbolKind.Schema;
+    schema: string;
+}
+export interface TableIdentifier {
+    kind?: typeof SymbolKind.Table;
+    schema?: string;
+    table: string;
+}
+export interface ColumnIdentifier {
+    kind?: typeof SymbolKind.Column;
+    schema?: string;
+    table: string;
+    column: string;
+}
+export interface EnumIdentifier {
+    kind?: typeof SymbolKind.Enum;
+    schema?: string;
+    name: string;
+}
+export interface EndpointRef {
+    schemaName?: string | null;
+    tableName: string;
+    fieldNames?: string[];
+}
+export interface RefIdentifier {
+    kind?: typeof MetadataKind.Ref;
+    endpoints: [EndpointRef, EndpointRef];
+}
+export interface DepIdentifier {
+    kind?: typeof MetadataKind.Dep;
+    upstream: EndpointRef;
+    downstream: EndpointRef;
+}
+export interface NoteIdentifier {
+    kind?: typeof SymbolKind.StickyNote;
+    name: string;
+}
+export interface TableGroupIdentifier {
+    kind?: typeof SymbolKind.TableGroup;
+    schema?: string;
+    name: string;
+}

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

@@ -0,0 +1,6 @@
+import { Filepath } from '../../../core/types/filepath';
+import { default as Compiler } from '../../index';
+import { TextEdit } from './applyTextEdits';
+import { ElementIdentifier } from './types';
+export declare function updateElementSettingEdit(this: Compiler, filepath: Filepath, target: ElementIdentifier, settingName: string, value: string | null | undefined): TextEdit[];
+export declare function updateElementSetting(this: Compiler, filepath: Filepath, target: ElementIdentifier, settingName: string, value: string | null | undefined): string;

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

@@ -0,0 +1,26 @@
+import { Filepath } from '../../../../core/types/filepath';
+import { NodeSymbol, SymbolKind } from '../../../../core/types/symbol';
+import { default as Compiler } from '../../../index';
+import { EndpointRef } from '../types';
+export type { ElementIdentifier } from '../types';
+export { findRefDefinition, type InlineRef, type StandaloneRef } from './ref';
+export declare function normalizeSchema(schema?: string | null): string;
+export declare function endpointsEqual(left: EndpointRef, right: EndpointRef): boolean;
+export declare function endpointMatches(candidate: EndpointRef, target: EndpointRef): boolean;
+export declare function normalizeTableName(input: string | {
+    schema?: string;
+    table: string;
+}): {
+    schema: string;
+    table: string;
+};
+/**
+ * Looks up an element symbol by its qualified name and kind.
+ */
+export declare function lookupElementSymbol(compiler: Compiler, filepath: Filepath, schema: string, name: string, kind?: SymbolKind): NodeSymbol | undefined;
+/**
+ * Removes surrounding double quotes from a string if present.
+ */
+export declare function stripQuotes(str: string): string;
+export declare function formatEndpoint(ep: EndpointRef): string;
+export declare function formatSetting(name: string, value: string | null | undefined): string;

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

@@ -0,0 +1,15 @@
+import { FunctionApplicationNode } from '../../../../core/types/nodes';
+import { Filepath } from '../../../../core/types/filepath';
+import { default as Compiler } from '../../../index';
+import { RefIdentifier } from '../types';
+export interface InlineRef {
+    kind: 'inline';
+    op: string;
+    fullStart: number;
+    fullEnd: number;
+}
+export interface StandaloneRef {
+    kind: 'standalone';
+    node: FunctionApplicationNode;
+}
+export declare function findRefDefinition(compiler: Compiler, filepath: Filepath, target: RefIdentifier): InlineRef | StandaloneRef | undefined;

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

@@ -35,6 +35,7 @@ export declare function isValidIdentifier(name: string): boolean;
  * addDoubleQuoteIfNeeded('user-name') => '"user-name"'
  */
 export declare function addDoubleQuoteIfNeeded(identifier: string): string;
+export declare function normalizeQualifiedName(...parts: string[]): string;
 /**
  * Unescapes a string by processing escape sequences.
  * Handles escaped quotes (\"), common escape sequences, unicode (\uHHHH), and arbitrary escapes.
@@ -99,3 +100,8 @@ export declare function formatRecordValue(recordValue: {
 export declare function splitQualifiedIdentifier(identifier: string): string[];
 export declare function collectTransitiveDependencies(compiler: Compiler, entrypoints: Filepath[]): Filepath[];
 export declare function allVisibleMembers(compiler: Compiler): Report<NodeSymbol[]>;
+/**
+ * Wraps a note value in the appropriate DBML quote style.
+ * Uses triple quotes for multiline content, single quotes otherwise.
+ */
+export declare function quoteNoteValue(value: string): string;

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

@@ -5,12 +5,13 @@ export declare const enum ScopeKind {
     INDEXES = 3,
     NOTE = 4,
     REF = 5,
-    PROJECT = 6,
-    CUSTOM = 7,
-    TOPLEVEL = 8,
-    TABLEPARTIAL = 9,
-    CHECKS = 10,
-    RECORDS = 11,
-    DIAGRAMVIEW = 12,
-    METADATA = 13
+    DEP = 6,
+    PROJECT = 7,
+    CUSTOM = 8,
+    TOPLEVEL = 9,
+    TABLEPARTIAL = 10,
+    CHECKS = 11,
+    RECORDS = 12,
+    DIAGRAMVIEW = 13,
+    METADATA = 14
 }

package/dist/src/core/global_modules/dep/bind.d.ts

@@ -0,0 +1,18 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileError } from '../../types/errors';
+import { ElementDeclarationNode } from '../../types/nodes';
+import { SyntaxToken } from '../../types/tokens';
+export default class DepBinder {
+    private compiler;
+    private declarationNode;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    });
+    bind(): CompileError[];
+    private bindBody;
+    private bindFields;
+    private checkColumnSelfLoop;
+    private endpointSymbol;
+    private endpointLevel;
+    private bindSubElements;
+}

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

@@ -0,0 +1,2 @@
+import { GlobalModule } from '../types';
+export declare const depModule: GlobalModule;

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

@@ -0,0 +1,18 @@
+import { Dep } from '../../types/schemaJson';
+import { DepMetadata, Filepath } from '../../types';
+import { default as Compiler } from '../../../compiler';
+import { default as Report } from '../../types/report';
+export declare class DepInterpreter {
+    private compiler;
+    private metadata;
+    private declarationNode;
+    private filepath;
+    private dep;
+    constructor(compiler: Compiler, metadata: DepMetadata, filepath: Filepath);
+    interpret(): Report<Dep>;
+    private interpretName;
+    private interpretEdges;
+    private interpretSettings;
+    private consumeSettings;
+    private extractAttrValue;
+}

package/dist/src/core/global_modules/program/utils/dep.d.ts

@@ -0,0 +1,4 @@
+import { CompileError } from '../../../types/errors';
+import { Dep } from '../../../types/schemaJson';
+import { NodeMetadata } from '../../../types/symbol/metadata';
+export declare function validateDepBlocks(dep: Dep, meta: NodeMetadata): CompileError[];

package/dist/src/core/global_modules/program/utils/external.d.ts

@@ -0,0 +1,3 @@
+import { Database, ElementRef } from '../../../types/schemaJson';
+import { NodeSymbol } from '../../../types/symbol';
+export declare function pushExternal(db: Database, member: NodeSymbol, ref: ElementRef): void;

package/dist/src/core/global_modules/program/utils/index.d.ts

@@ -0,0 +1,3 @@
+export { pushExternal } from './external';
+export { validateRecords } from './records';
+export { validateDepBlocks } from './dep';

package/dist/src/core/global_modules/program/utils/records.d.ts

@@ -0,0 +1,6 @@
+import { default as Compiler } from '../../../../compiler/index';
+import { CompileWarning } from '../../../types/errors';
+import { Filepath } from '../../../types/filepath';
+import { Ref } from '../../../types/schemaJson';
+import { ProgramSymbol } from '../../../types/symbol';
+export declare function validateRecords(compiler: Compiler, programSymbol: ProgramSymbol, refs: Ref[], filepath: Filepath): CompileWarning[];

package/dist/src/core/global_modules/table/bind.d.ts

@@ -9,6 +9,8 @@ export default class TableBinder {
         type: SyntaxToken;
     });
     bind(): CompileError[];
+    private bindHeaderSettings;
+    private bindInlineDepValue;
     private bindBody;
     private bindFields;
     private tryToBindColumnType;

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

@@ -2,7 +2,7 @@ import { default as Compiler } from '../../compiler';
 import { Filepath, ProgramSymbol } from '../types';
 import { PrimaryExpressionNode, SyntaxNode, VariableNode } from '../types/nodes';
 import { default as Report } from '../types/report';
-import { NodeSymbol } from '../types/symbol';
+import { SymbolKind, NodeSymbol } from '../types/symbol';
 export declare function shouldInterpretNode(compiler: Compiler, node: SyntaxNode): boolean;
 export declare function getNodeMemberSymbols(compiler: Compiler, node: SyntaxNode): Report<NodeSymbol[]>;
 export declare function scanNonListNodeForBinding(node?: SyntaxNode): {
@@ -14,5 +14,6 @@ export declare function scanNonListNodeForBinding(node?: SyntaxNode): {
     })[];
 }[];
 export declare function nodeRefereeOfLeftExpression(compiler: Compiler, node: SyntaxNode): NodeSymbol | undefined;
+export declare function nodeRefereeOfEndpoint(compiler: Compiler, globalSymbol: NodeSymbol, node: SyntaxNode, terminalKind: SymbolKind.Column | SymbolKind.Table): Report<NodeSymbol | undefined>;
 export declare function getDefaultSchemaSymbol(compiler: Compiler, globalSymbol: NodeSymbol): NodeSymbol | undefined;
 export declare function getProgramSymbol(compiler: Compiler, filepath: Filepath): ProgramSymbol | undefined;

package/dist/src/core/local_modules/dep/index.d.ts

@@ -0,0 +1,2 @@
+import { LocalModule } from '../types';
+export declare const depModule: LocalModule;

package/dist/src/core/local_modules/dep/validate.d.ts

@@ -0,0 +1,19 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileError } from '../../types/errors';
+import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode, ListExpressionNode } from '../../types/nodes';
+import { default as Report } from '../../types/report';
+import { Settings } from '../../utils/validate';
+export default class DepValidator {
+    private declarationNode;
+    private compiler;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode);
+    validate(): CompileError[];
+    private validateSettings;
+    private validateContext;
+    private validateName;
+    private validateAlias;
+    validateBody(body?: FunctionApplicationNode | BlockExpressionNode): CompileError[];
+    validateFields(fields: FunctionApplicationNode[]): CompileError[];
+    private validateSubElements;
+}
+export declare function validateDepSettings(settings: ListExpressionNode): Report<Settings>;