@dbml/parse 9.0.0-alpha.2 → 9.0.0-alpha.21

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 { DBMLCompletionItemProvider, DBMLDefinitionProvider, DBMLDiagnosticsProvider, DBMLReferencesProvider } from '../services/index';
 import { DbmlProjectLayout } from './projectLayout';
-import { DiagramViewBlock, DepBlock, findDiagramViewBlocks, findDepBlocks } 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, DepBlock, TableNameInput, TextEdit } from './queries/transform';
-export { addDoubleQuoteIfNeeded, escapeString, formatRecordValue, isValidIdentifier, splitQualifiedIdentifier, unescapeString, findDiagramViewBlocks, findDepBlocks, };
+export type { TextEdit } from './queries/transform';
+export { addDoubleQuoteIfNeeded, escapeString, formatRecordValue, isValidIdentifier, normalizeQualifiedName, splitQualifiedIdentifier, unescapeString, };
 export default class Compiler {
     layout: DbmlProjectLayout;
     readonly nodeIdGenerator: SyntaxNodeIdGenerator;
@@ -30,7 +29,7 @@ export default class Compiler {
     validateFile: (filepath: Filepath) => import('../core/types/report').default<void>;
     nodeFullname: (node: SyntaxNode) => import('../core/types/report').default<string[] | undefined> | import('../core/types/report').default<typeof import('..').UNHANDLED>;
     nodeAlias: (node: SyntaxNode) => import('../core/types/report').default<typeof import('..').UNHANDLED> | import('../core/types/report').default<string | undefined>;
-    nodeSettings: (node: SyntaxNode) => import('../core/types/report').default<typeof import('..').UNHANDLED> | import('../core/types/report').default<import('../core/utils/validate').Settings>;
+    nodeSettings: (node: SyntaxNode) => import('../core/types/report').default<import('../core/utils/validate').Settings> | import('../core/types/report').default<typeof import('..').UNHANDLED>;
     canonicalName: (filepath: Filepath, symbol: import('../core/types/symbol').NodeSymbol) => import('../core/types/report').default<import('./queries/canonicalName').CanonicalName | undefined>;
     bindNode: (node: SyntaxNode) => import('../core/types/report').default<typeof import('..').UNHANDLED> | import('../core/types/report').default<void>;
     bindFile: (filepath: Filepath) => import('../core/types/report').default<void>;
@@ -72,17 +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[];
     };
-    findDiagramViewBlocks(filepath: Filepath): DiagramViewBlock[];
-    syncDep: (filepath: Filepath, operations: import('..').DepSyncOperation[], blocks?: DepBlock[] | undefined) => {
+    syncDep: (filepath: Filepath, operations: import('..').DepSyncOperation[], blocks?: import('..').DepBlock[] | undefined) => {
         newDbml: string;
         edits: import('.').TextEdit[];
     };
-    findDepBlocks(filepath: Filepath): DepBlock[];
     readonly token: {
         invalidStream: (filepath: Filepath) => readonly import('..').SyntaxToken[];
         flatStream: (filepath: Filepath) => readonly import('..').SyntaxToken[];

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

@@ -1,5 +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

@@ -1,7 +1,7 @@
 import { Filepath } from '../../../core/types/filepath';
+import { ElementDeclarationNode, ProgramNode } from '../../../core/types/nodes';
 import { default as Compiler } from '../../index';
 import { TextEdit } from './applyTextEdits';
-/** One endpoint of a dep edge. `fieldNames` is empty for a table-level edge. */
 export interface DepEndpointRef {
     schemaName?: string | null;
     tableName: string;
@@ -12,79 +12,43 @@ export interface DepSyncEdge {
     downstream: DepEndpointRef;
 }
 export interface DepSyncOperation {
-    operation: 'create' | 'update';
-    /** The edge that identifies the target block (table-level: empty fieldNames). */
+    operation: 'create' | 'update' | 'remove';
+    /** The edge that identifies the target block (table-level: empty fields). */
     edge: DepSyncEdge;
-    color?: string;
-}
-/**
- * A `color` setting found on a block.
- *
- * `kind` says how to overwrite it:
- *  - `attribute` -> replace just the `color: <hex>` attribute at `start..end`
- *    (inside a `[...]` list that may hold other settings).
- *  - `subDeclaration` -> replace the whole `color: <hex>` body line at
- *    `start..end`.
- */
-interface ColorSetting {
-    kind: 'attribute' | 'subDeclaration';
-    start: number;
-    end: number;
+    /** 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[];
-    /**
-     * An existing header `[...]` attribute list (without a color setting), so a
-     * color can be inserted into it instead of adding a second `[...]`.
-     * Records the offset just before the list's closing `]`.
-     */
-    attributeListInsertAt?: number;
-    attributeListIsEmpty?: boolean;
-    /**
-     * Offset of the block body `{` - where to add a header `[color: ...]` for a
-     * block-form Dep that has no attribute list.
-     */
-    bodyOpenAt?: number;
-    /**
-     * End offset of a short-form (`Dep: a -> b`) body that has no setting list -
-     * where to append ` [color: ...]`.
-     */
-    shortFormEnd?: number;
-    /** The existing color setting (header list, inline list, or sub-declaration), if any. */
-    color?: ColorSetting;
 }
-/**
- * Returns every `Dep` block in `source`.
- * On any lex or parse error, returns [] - there is no reliable way to read
- * dep blocks from malformed DBML (mirrors findDiagramViewBlocks).
- */
-export declare function findDepBlocks(source: string): DepBlock[];
 export interface InlineDep {
     edge: DepSyncEdge;
-    stripStart: number;
-    stripEnd: number;
+    fullStart: number;
+    fullEnd: number;
 }
-export declare function findInlineDeps(source: string): InlineDep[];
-/**
- * Emit a `Dep` block for one edge with a `[color]` setting:
- *
- *   Dep [color: <hex>] {
- *     <upstream> -> <downstream>
- *   }
- */
-export declare function generateDepBlock(edge: DepSyncEdge, color: string): string;
 /**
  * Synchronizes `Dep` blocks in the DBML source at `filepath`.
- *
- * @param filepath   The file whose source should be rewritten.
- * @param operations Array of create/update operations to apply.
- * @param blocks     Optional pre-parsed blocks from findDepBlocks.
- * @returns The new DBML source and the text edits applied.
+ * 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[];
 };
-export {};
+/**
+ * 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,11 +5,12 @@ 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
+    DEP = 6,
+    PROJECT = 7,
+    CUSTOM = 8,
+    TOPLEVEL = 9,
+    TABLEPARTIAL = 10,
+    CHECKS = 11,
+    RECORDS = 12,
+    DIAGRAMVIEW = 13
 }

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

@@ -11,5 +11,8 @@ export default class DepBinder {
     bind(): CompileError[];
     private bindBody;
     private bindFields;
+    private checkColumnSelfLoop;
+    private endpointSymbol;
+    private endpointLevel;
     private bindSubElements;
 }

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

@@ -12,22 +12,6 @@ export declare class DepInterpreter {
     interpret(): Report<Dep>;
     private interpretName;
     private interpretEdges;
-    /**
-     * Read settings into `dep.note` and `dep.custom`.
-     *
-     * Settings come from THREE sources, in this order:
-     *   1. The top-level attribute list on the Dep header
-     *      (e.g. `Dep my_block [color: 'blue'] { ... }`).
-     *   2. Per-field setting lists inside the body
-     *      (e.g. `Dep { a -> b [note: 'x'] }`).
-     *   3. Sub-element declarations inside the body
-     *      (e.g. `Dep { a -> b; note: 'x'; materialized: 'view' }`).
-     *
-     * All three sources write into the same `custom` object (with `note`
-     * routed to the typed slot instead). Precedence is last-write-wins by
-     * virtue of plain object assignment — settings later in the source
-     * file overwrite earlier ones with the same key.
-     */
     private interpretSettings;
     private consumeSettings;
     private extractAttrValue;

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

@@ -17,7 +17,5 @@ export default class ProgramInterpreter {
     private interpretUseSymbol;
     private interpretAllMetadata;
     private interpretAllAliases;
-    private validateRecords;
-    private collectPartialRefs;
     private pushElement;
 }

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/records/utils/constraints/helper.d.ts

@@ -2,25 +2,12 @@ import { default as Compiler } from '../../../../../compiler/index';
 import { CompileWarning } from '../../../../types/errors';
 import { RecordValue, TableRecord } from '../../../../types/schemaJson';
 import { ColumnSymbol } from '../../../../types/symbol';
-export interface ColumnInfo {
-    name: string;
-    pk: boolean;
-    unique: boolean;
-    increment: boolean;
-    notNull: boolean;
-    dbdefault?: {
-        value: string | number;
-        type: string;
-    };
-    typeName: string;
-}
-export declare function columnInfoFromSymbol(col: ColumnSymbol, compiler: Compiler): ColumnInfo;
 export declare function toKeyedRows(record: TableRecord): Record<string, RecordValue>[];
 export declare function makeTableKey(schema: string | null, table: string): string;
-export declare function extractKeyValueWithDefault(row: Record<string, RecordValue>, columnNames: string[], columns?: (ColumnInfo | undefined)[]): string;
-export declare function hasNullWithoutDefaultInKey(row: Record<string, RecordValue>, columnNames: string[], columns?: (ColumnInfo | undefined)[]): boolean;
-export declare function isAutoIncrementColumn(column: ColumnInfo): boolean;
+export declare function extractKeyValueWithDefault(compiler: Compiler, row: Record<string, RecordValue>, columns: ColumnSymbol[]): string;
+export declare function hasNullWithoutDefaultInKey(compiler: Compiler, row: Record<string, RecordValue>, columns: ColumnSymbol[]): boolean;
 export declare function formatFullColumnName(schemaName: string | null, tableName: string, columnName: string): string;
 export declare function formatFullColumnNames(schemaName: string | null, tableName: string, columnNames: string[]): string;
-export declare function formatValues(row: Record<string, RecordValue>, columnNames: string[]): string;
+export declare function formatValues(compiler: Compiler, row: Record<string, RecordValue>, columns: ColumnSymbol[]): string;
+export declare function getDiagnosticAnchorValues(row: Record<string, RecordValue>, columnNames: string[]): RecordValue[];
 export declare function createConstraintWarning(compiler: Compiler, recordValue: RecordValue, message: string): CompileWarning;

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

@@ -2,7 +2,7 @@ import { default as Compiler } from '../../compiler';
 import { RelationCardinality } 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,4 +14,5 @@ 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 getMultiplicities(op: string): [RelationCardinality, RelationCardinality] | undefined;

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

@@ -8,6 +8,7 @@ export default class DepValidator {
     private compiler;
     constructor(compiler: Compiler, declarationNode: ElementDeclarationNode);
     validate(): CompileError[];
+    private validateSettings;
     private validateContext;
     private validateName;
     private validateAlias;

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

@@ -113,9 +113,13 @@ export declare enum CompileErrorCode {
     UNSUPPORTED = 5000,
     CIRCULAR_REF = 5001,
     SAME_ENDPOINT = 5002,
-    UNEQUAL_FIELDS_BINARY_REF = 5003,
-    CONFLICTING_SETTING = 5004,
-    TABLE_REAPPEAR_IN_TABLEGROUP = 5005
+    DEP_SELF_LOOP = 5003,
+    DEP_MIXED_DOWNSTREAM_TABLES = 5004,
+    DEP_DUPLICATE_DOWNSTREAM_TABLE = 5005,
+    DEP_MIXED_LEVEL = 5006,
+    UNEQUAL_FIELDS_BINARY_REF = 5007,
+    CONFLICTING_SETTING = 5008,
+    TABLE_REAPPEAR_IN_TABLEGROUP = 5009
 }
 export declare class CompileError extends Error {
     code: Readonly<CompileErrorCode>;

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

@@ -182,7 +182,7 @@ export interface Dep {
         value: string;
         token: TokenPosition;
     };
-    custom?: Record<string, string | number | boolean | null>;
+    metadata?: Record<string, string | number | boolean | null>;
     token: TokenPosition;
 }
 export interface DepEdge {
@@ -196,11 +196,14 @@ export interface DepEndpoint {
     fieldNames: string[];
     token: TokenPosition;
 }
+export declare const DEP_DOWNSTREAM: "->";
+export declare const DEP_UPSTREAM: "<-";
+export type DepDirection = typeof DEP_DOWNSTREAM | typeof DEP_UPSTREAM;
 export interface InlineDep {
     schemaName: string | null;
     tableName: string;
     fieldNames: string[];
-    direction: '->' | '<-';
+    direction: DepDirection;
     token: TokenPosition;
 }
 export interface Enum {

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

@@ -150,6 +150,7 @@ export declare class ColumnSymbol extends NodeSymbol {
     pk(compiler: Compiler): boolean;
     unique(compiler: Compiler): boolean;
     nullable(compiler: Compiler): boolean | undefined;
+    isIncrementSet(compiler: Compiler): boolean;
     increment(compiler: Compiler): boolean;
     default(compiler: Compiler): {
         type: 'number' | 'string' | 'boolean' | 'expression';

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

@@ -1,4 +1,4 @@
-import { ElementDeclarationNode, FunctionApplicationNode, FunctionExpressionNode, IdentifierStreamNode, PrimaryExpressionNode, SyntaxNode, TupleExpressionNode, VariableNode } from '../types/nodes';
+import { AttributeNode, ElementDeclarationNode, FunctionApplicationNode, FunctionExpressionNode, IdentifierStreamNode, PrimaryExpressionNode, SyntaxNode, TupleExpressionNode, VariableNode } from '../types/nodes';
 import { SyntaxToken } from '../types/tokens';
 export declare function extractVariableNode(value?: unknown): SyntaxToken | undefined;
 export declare function extractStringFromIdentifierStream(stream?: IdentifierStreamNode): string | undefined;
@@ -35,3 +35,4 @@ export declare function extractVariableFromExpression(node?: SyntaxNode): string
 export declare function extractVarNameFromPrimaryVariable(node?: PrimaryExpressionNode & {
     expression: VariableNode;
 }): string | undefined;
+export declare function extractSettingName(attr: AttributeNode): string | undefined;

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

@@ -0,0 +1,18 @@
+import { SyntaxNode } from '../types/nodes';
+import { TextEdit } from '../../compiler/queries/transform/applyTextEdits';
+/**
+ * Produces a TextEdit that updates an existing note's value.
+ * Returns undefined if no note exists.
+ */
+export declare function updateNoteEdit(declaration: SyntaxNode, newValue: string): TextEdit | undefined;
+/**
+ * Produces a TextEdit that removes an existing note.
+ * Returns undefined if no note exists.
+ */
+export declare function removeNoteEdit(declaration: SyntaxNode): TextEdit | undefined;
+/**
+ * Produces a TextEdit that adds a note to an element.
+ * Prioritizes body note form for block elements, falls back to setting attribute.
+ * Returns undefined if a note already exists.
+ */
+export declare function addNoteEdit(declaration: SyntaxNode, value: string): TextEdit | undefined;

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

@@ -0,0 +1,16 @@
+import { ListExpressionNode, AttributeNode, ElementDeclarationNode, SyntaxNode } from '../types/nodes';
+import { TextEdit } from '../../compiler/queries/transform/applyTextEdits';
+export type SettingLocation = {
+    kind: 'attribute';
+    settingsList: ListExpressionNode;
+    settingNode: AttributeNode;
+    settingIndex: number;
+} | {
+    kind: 'body';
+    declaration: ElementDeclarationNode;
+} | undefined;
+export declare function findSetting(declaration: SyntaxNode, settingName: string): SettingLocation;
+export declare function addSettingEdit(declaration: SyntaxNode, setting: string): TextEdit | undefined;
+export declare function updateSettingEdit(declaration: SyntaxNode, settingName: string, value: string | null | undefined, source: string): TextEdit | undefined;
+export declare function removeSettingEdit(declaration: SyntaxNode, settingName: string, source: string): TextEdit | undefined;
+export declare function findBodySetting(declaration: ElementDeclarationNode, settingName: string): ElementDeclarationNode | undefined;

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

@@ -24,6 +24,7 @@ export declare function isValidPartialInjection(node?: SyntaxNode): node is Pref
     };
 };
 export declare function isRelationshipOp(op?: string): boolean;
+export declare function isDependencyOp(op?: string): boolean;
 export declare function isValidColor(value?: SyntaxNode): boolean;
 export declare function isValidDefaultValue(value?: SyntaxNode): boolean;
 export type SignedNumberExpression = (PrimaryExpressionNode & {
@@ -38,6 +39,7 @@ export type SignedNumberExpression = (PrimaryExpressionNode & {
 });
 export declare function isExpressionASignedNumberExpression(value?: SyntaxNode): value is SignedNumberExpression;
 export declare function isUnaryRelationship(value?: SyntaxNode): value is PrefixExpressionNode;
+export declare function isUnaryDependency(value?: SyntaxNode): value is PrefixExpressionNode;
 export declare function isTupleOfVariables(value?: SyntaxNode): value is TupleExpressionNode & {
     elementList: (PrimaryExpressionNode & {
         expression: VariableNode;

package/dist/src/index.d.ts

@@ -4,15 +4,18 @@ export { Filepath } from './core/types/filepath';
 export { UNHANDLED, type Unhandled, } from './core/types/module';
 export { ElementKind } from './core/types/keywords';
 export { type NodeSymbol, SymbolKind, } from './core/types/symbol';
+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 type { Position, } from './core/types';
-export { ScopeKind, splitQualifiedIdentifier, unescapeString, escapeString, formatRecordValue, isValidIdentifier, addDoubleQuoteIfNeeded, } from './compiler/index';
+export { ScopeKind, splitQualifiedIdentifier, unescapeString, escapeString, formatRecordValue, 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 RelationCardinality, 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, } from './core/types/schemaJson';
 export type { DiagramViewSyncOperation, DiagramViewBlock, TextEdit, } from './compiler/queries/transform';
+export { findDiagramViewBlocks, findDepBlocks } from './compiler/queries/transform';
 export type { DepSyncOperation, DepSyncEdge, DepEndpointRef, DepBlock, } from './compiler/queries/transform';
+export type { ElementIdentifier, SchemaIdentifier, TableIdentifier, ColumnIdentifier, EnumIdentifier, EndpointRef, RefIdentifier, DepIdentifier, NoteIdentifier, TableGroupIdentifier, } from './compiler/queries/transform';
 export { dbmlLanguageConfig, dbmlMonarchTokensProvider, } from './services/monarch';
 export * from './compiler/projectLayout/layout';
 export { Compiler };

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@dbml/parse",
-  "version": "9.0.0-alpha.2",
+  "version": "9.0.0-alpha.21",
   "description": "DBML parser v2",
   "author": "Holistics <dev@holistics.io>",
   "license": "Apache-2.0",
@@ -50,5 +50,5 @@
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "29e83a7d46ba317c1011a43021860348b8c829b5"
+  "gitHead": "a615886aca6945409c3e3188e8058f7eb9096e66"
 }

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

@@ -1,23 +0,0 @@
-import { Filepath } from '../../../core/types/filepath';
-import { NodeSymbol } from '../../../core/types/symbol';
-import { default as Compiler } from '../../index';
-export type TableNameInput = string | {
-    schema?: string;
-    table: string;
-};
-/**
- * Normalizes a table name input to { schema, table } format.
- * Properly handles quoted identifiers with dots inside.
- */
-export declare function normalizeTableName(input: TableNameInput): {
-    schema: string;
-    table: string;
-};
-/**
- * Looks up a table symbol by matching its full qualified name.
- */
-export declare function lookupTableSymbol(compiler: Compiler, filepath: Filepath, schema: string, table: string): NodeSymbol | null;
-/**
- * Removes surrounding double quotes from a string if present.
- */
-export declare function stripQuotes(str: string): string;

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

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