@dbml/parse 8.3.1-custom-metadata.2 → 8.3.1-custom-metadata.4

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

@@ -30,7 +30,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>;
@@ -100,7 +100,7 @@ export default class Compiler {
             token: undefined;
             index: undefined;
         };
-        element: (filepath: Filepath, offset: number) => Readonly<import('../core/types/nodes').ElementDeclarationNode | import('../core/types/nodes').ProgramNode | import('../core/types/nodes').MetadataDeclarationNode>;
+        element: (filepath: Filepath, offset: number) => Readonly<import('../core/types/nodes').ElementDeclarationNode | import('../core/types/nodes').ProgramNode>;
         scope: (filepath: Filepath, offset: number) => import('../core/types/symbol').NodeSymbol[] | undefined;
         scopeKind: (filepath: Filepath, offset: number) => import('./types').ScopeKind;
     };

package/dist/src/compiler/queries/container/element.d.ts

@@ -1,4 +1,4 @@
 import { Filepath } from '../../../core/types/filepath';
-import { ElementDeclarationNode, MetadataDeclarationNode, ProgramNode } from '../../../core/types/nodes';
+import { ElementDeclarationNode, ProgramNode } from '../../../core/types/nodes';
 import { default as Compiler } from '../../index';
-export declare function containerElement(this: Compiler, filepath: Filepath, offset: number): Readonly<ElementDeclarationNode | MetadataDeclarationNode | ProgramNode>;
+export declare function containerElement(this: Compiler, filepath: Filepath, offset: number): Readonly<ElementDeclarationNode | ProgramNode>;

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

@@ -1,10 +1,10 @@
 import { default as Compiler } from '../../../compiler';
 import { CompileError } from '../../types';
-import { MetadataDeclarationNode } from '../../types/nodes';
+import { ElementDeclarationNode } from '../../types/nodes';
 export default class MetadataBinder {
     private compiler;
     private declarationNode;
-    constructor(compiler: Compiler, declarationNode: MetadataDeclarationNode);
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode);
     bind(): CompileError[];
     private bindTargetElement;
     private bindBody;

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

@@ -1,19 +1,14 @@
 import { default as Compiler } from '../../../compiler';
-import { SettingName, Filepath } from '../../types';
+import { Filepath } from '../../types';
 import { MetadataElementMetadata } from '../../types/symbol/metadata';
 import { default as Report } from '../../types/report';
-import { MetadataElement } from '../../types/schemaJson';
-export declare const TABLE_BUILTIN_SETTINGS: readonly SettingName[];
-export declare const TABLEGROUP_BUILTIN_SETTINGS: readonly SettingName[];
-export declare const NOTE_BUILTIN_SETTINGS: readonly SettingName[];
-export declare const COLUMN_BUILTIN_SETTINGS: readonly SettingName[];
+import { MetadataValues } from '../../types/schemaJson';
 export default class MetadataInterpreter {
     private declarationNode;
     private compiler;
     private filepath;
-    private metadata;
+    private values;
     constructor(compiler: Compiler, metadata: MetadataElementMetadata, filepath: Filepath);
-    interpret(): Report<MetadataElement>;
-    private interpretTarget;
+    interpret(): Report<MetadataValues>;
     private interpretValues;
 }

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

@@ -0,0 +1,29 @@
+import { default as Compiler } from '../../../compiler/index';
+import { Filepath, SettingName } from '../../types';
+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;
+/**
+  * 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
+  * - `assign`: Write the metadata value to the element builtin props (e.g. write `table.note` instead of `table.metadata`)
+  */
+interface MetadataField<T extends MetadataTarget> {
+    /** Check if the metadata value is syntactically correct */
+    isValidBuiltinFieldValue(node?: SyntaxNode): boolean;
+    message: string;
+    /** Write the metadata value to the element builtin props (e.g. write to `table.note`) */
+    assignBuiltinField(element: Partial<T>, value: string, token: TokenPosition): void;
+}
+export type MetadataFieldRegistry<T extends MetadataTarget, K extends SettingName = SettingName> = Record<K, MetadataField<T>>;
+type NameWithSymbolKind = {
+    name: string;
+    symbolKind: SymbolKind;
+};
+/** @internal Exported for testing only. */
+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/note/interpret.d.ts

@@ -1,8 +1,9 @@
 import { Note } from '../../types/schemaJson';
 import { default as Compiler } from '../../../compiler';
 import { SettingName, Filepath, NoteSymbol } from '../../types';
-import { FieldAssignMap } from '../metadata/fieldSpec';
 import { default as Report } from '../../types/report';
+import { MetadataFieldRegistry } from '../metadata/utils';
+export declare const NOTE_METADATA_FIELDS: MetadataFieldRegistry<Note, SettingName.Color>;
 export declare class StickyNoteInterpreter {
     private declarationNode;
     private symbol;
@@ -16,4 +17,3 @@ export declare class StickyNoteInterpreter {
     private interpretBody;
     private interpretNote;
 }
-export declare const NOTE_FIELD_ASSIGNS: FieldAssignMap<Note, SettingName.Color>;

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

@@ -11,14 +11,11 @@ export default class ProgramInterpreter {
     private errors;
     private warnings;
     private db;
-    private emittedBySymbol;
     constructor(compiler: Compiler, symbol: ProgramSymbol, filepath: Filepath);
     interpret(): Report<SchemaElement | SchemaElement[] | undefined>;
     private interpretAllSymbols;
     private interpretUseSymbol;
     private interpretAllMetadata;
-    private writeBuiltinFields;
-    private attachMetadata;
     private interpretAllAliases;
     private validateRecords;
     private collectPartialRefs;

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

@@ -3,9 +3,9 @@ import { SettingName } from '../../types/keywords';
 import { ElementDeclarationNode } from '../../types/nodes';
 import { default as Report } from '../../types/report';
 import { Column, Table } from '../../types/schemaJson';
-import { FieldAssignMap } from '../metadata/fieldSpec';
 import { Filepath } from '../../types/filepath';
 import { TableSymbol } from '../../types/symbol/symbols';
+import { MetadataFieldRegistry } from '../metadata/utils';
 export declare class TableInterpreter {
     private declarationNode;
     private compiler;
@@ -15,6 +15,7 @@ export declare class TableInterpreter {
     private pkColumns;
     constructor(compiler: Compiler, declarationNode: ElementDeclarationNode, symbol: TableSymbol, filepath: Filepath);
     interpret(): Report<Table>;
+    private attachTableAndColumnMetadata;
     private interpretName;
     private interpretAlias;
     private interpretSettingList;
@@ -26,5 +27,11 @@ export declare class TableInterpreter {
     private interpretIndexes;
     private interpretChecks;
 }
-export declare const TABLE_FIELD_ASSIGNS: FieldAssignMap<Table, SettingName.Note | SettingName.HeaderColor>;
-export declare const COLUMN_FIELD_ASSIGNS: FieldAssignMap<Column, SettingName.Note | SettingName.PK | SettingName.Unique | SettingName.Increment>;
+/**
+  * Settings that are excluded from custom metadata for inline metadata for Column
+  * Different from what we extract from metadata block for Column because some settings value types are not supported yet, mostly boolean keys without values ([pk, not null])
+  * TODO: Catch these settings when we support more data types for custom metadata
+  */
+export declare const RECOGNIZED_COLUMN_SETTINGS: readonly SettingName[];
+export declare const TABLE_METADATA_FIELDS: MetadataFieldRegistry<Table, SettingName.Note | SettingName.HeaderColor>;
+export declare const COLUMN_METADATA_FIELDS: MetadataFieldRegistry<Column, SettingName.Note>;

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

@@ -1,8 +1,9 @@
 import { TableGroup } from '../../types/schemaJson';
 import { default as Compiler } from '../../../compiler';
 import { SettingName, Filepath, TableGroupSymbol } from '../../types';
-import { FieldAssignMap } from '../metadata/fieldSpec';
 import { default as Report } from '../../types/report';
+import { MetadataFieldRegistry } from '../metadata/utils';
+export declare const TABLEGROUP_METADATA_FIELDS: MetadataFieldRegistry<TableGroup, SettingName.Note | SettingName.Color>;
 export declare class TableGroupInterpreter {
     private compiler;
     private symbol;
@@ -17,4 +18,3 @@ export declare class TableGroupInterpreter {
     private interpretFields;
     private interpretSettingList;
 }
-export declare const TABLEGROUP_FIELD_ASSIGNS: FieldAssignMap<TableGroup, SettingName.Note | SettingName.Color>;

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

@@ -1,5 +1,5 @@
 import { default as Compiler } from '../../compiler';
-import { Filepath, RelationCardinality } from '../types';
+import { Filepath, ProgramSymbol, RelationCardinality } from '../types';
 import { PrimaryExpressionNode, SyntaxNode, VariableNode } from '../types/nodes';
 import { default as Report } from '../types/report';
 import { NodeSymbol } from '../types/symbol';
@@ -16,4 +16,4 @@ export declare function scanNonListNodeForBinding(node?: SyntaxNode): {
 export declare function nodeRefereeOfLeftExpression(compiler: Compiler, node: SyntaxNode): NodeSymbol | undefined;
 export declare function getMultiplicities(op: string): [RelationCardinality, RelationCardinality] | undefined;
 export declare function getDefaultSchemaSymbol(compiler: Compiler, globalSymbol: NodeSymbol): NodeSymbol | undefined;
-export declare function getGlobalSymbol(compiler: Compiler, filepath: Filepath): NodeSymbol | undefined;
+export declare function getProgramSymbol(compiler: Compiler, filepath: Filepath): ProgramSymbol | undefined;

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

@@ -0,0 +1,7 @@
+import { CompileError, CompileErrorCode, MetadataTargetKind } from '../../types';
+import { AttributeNode, ElementDeclarationNode } from '../../types/nodes';
+export declare function getMetadataTargetKind(node: ElementDeclarationNode): MetadataTargetKind | undefined;
+export declare function validateCustomInlineMetadata(name: string, attrs: AttributeNode[], errorCodes: {
+    duplicate: CompileErrorCode;
+    invalidValue: CompileErrorCode;
+}): CompileError[];

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

@@ -1,10 +1,10 @@
 import { default as Compiler } from '../../../compiler';
 import { CompileError } from '../../types/errors';
-import { MetadataDeclarationNode } from '../../types/nodes';
+import { ElementDeclarationNode } from '../../types/nodes';
 export default class MetadataValidator {
     private compiler;
     private declarationNode;
-    constructor(compiler: Compiler, declarationNode: MetadataDeclarationNode);
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode);
     validate(): CompileError[];
     private validateTargetKind;
     private validateTargetName;

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

@@ -1,9 +1,6 @@
 import { default as Compiler } from '../../../compiler';
 import { CompileError } from '../../types/errors';
-import { SettingName } from '../../types/keywords';
 import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode } from '../../types/nodes';
-import { FieldValidateMap } from '../../global_modules/metadata/fieldSpec';
-export declare const NOTE_FIELD_SPECS: FieldValidateMap<SettingName.Color>;
 export default class NoteValidator {
     private compiler;
     private declarationNode;

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

@@ -1,12 +1,8 @@
 import { default as Compiler } from '../../../compiler';
 import { CompileError } from '../../types/errors';
-import { SettingName } from '../../types/keywords';
 import { ElementDeclarationNode, ExpressionNode, ListExpressionNode } from '../../types/nodes';
 import { default as Report } from '../../types/report';
 import { Settings } from '../../utils/validate';
-import { FieldValidateMap } from '../../global_modules/metadata/fieldSpec';
-export declare const TABLE_FIELD_SPECS: FieldValidateMap<SettingName.Note | SettingName.HeaderColor>;
-export declare const COLUMN_FIELD_SPECS: FieldValidateMap<SettingName.Note | SettingName.PK | SettingName.Unique | SettingName.Increment>;
 export default class TableValidator {
     private declarationNode;
     private compiler;

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

@@ -1,11 +1,8 @@
 import { default as Compiler } from '../../../compiler';
 import { CompileError } from '../../types/errors';
-import { SettingName } from '../../types/keywords';
 import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode, ListExpressionNode } from '../../types/nodes';
 import { default as Report } from '../../types/report';
 import { Settings } from '../../utils/validate';
-import { FieldValidateMap } from '../../global_modules/metadata/fieldSpec';
-export declare const TABLEGROUP_FIELD_SPECS: FieldValidateMap<SettingName.Note | SettingName.Color>;
 export default class TableGroupValidator {
     private declarationNode;
     private compiler;

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

@@ -32,7 +32,6 @@ export default class Parser {
     private synchronizeUseSpecifierList;
     private useSpecifier;
     private synchronizeProgram;
-    private metadataDeclaration;
     private elementDeclaration;
     private synchronizeElementDeclarationName;
     private synchronizeElementDeclarationAlias;

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

@@ -13,7 +13,8 @@ export declare enum ElementKind {
     DiagramViewTables = "tables",
     DiagramViewNotes = "notes",
     DiagramViewTableGroups = "tablegroups",
-    DiagramViewSchemas = "schemas"
+    DiagramViewSchemas = "schemas",
+    Metadata = "metadata"
 }
 export declare enum SettingName {
     Color = "color",

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

@@ -1,7 +1,7 @@
 import { Filepath } from './filepath';
 import { Internable } from './internable';
 import { ElementKind } from './keywords';
-import { ImportKind, MetadataTargetKind, SymbolKind } from './symbol';
+import { ImportKind, SymbolKind } from './symbol';
 import { Position } from './position';
 import { SyntaxToken } from './tokens';
 export type SyntaxNodeId = number;
@@ -36,7 +36,6 @@ export declare class SyntaxNode implements Internable<InternedSyntaxNode> {
 export declare enum SyntaxNodeKind {
     PROGRAM = "<program>",
     ELEMENT_DECLARATION = "<element-declaration>",
-    METADATA_DECLARATION = "<metadata-declaration>",
     USE_DECLARATION = "<use-declaration>",
     USE_SPECIFIER = "<use-specifier>",
     USE_SPECIFIER_LIST = "<use-specifier-list>",
@@ -61,17 +60,16 @@ export declare enum SyntaxNodeKind {
     WILDCARD = "<wildcard>"
 }
 export declare class ProgramNode extends SyntaxNode {
-    body: (UseDeclarationNode | ElementDeclarationNode | MetadataDeclarationNode)[];
+    body: (UseDeclarationNode | ElementDeclarationNode)[];
     eof?: SyntaxToken;
     source: string;
     constructor({ body, eof, source, }: {
-        body?: (UseDeclarationNode | ElementDeclarationNode | MetadataDeclarationNode)[];
+        body?: (UseDeclarationNode | ElementDeclarationNode)[];
         eof?: SyntaxToken;
         source: string;
     }, id: SyntaxNodeId, filepath: Filepath);
     get declarations(): ElementDeclarationNode[];
     get uses(): UseDeclarationNode[];
-    get metadata(): MetadataDeclarationNode[];
 }
 export declare class UseDeclarationNode extends SyntaxNode {
     useKeyword?: SyntaxToken;
@@ -110,31 +108,18 @@ export declare class UseSpecifierListNode extends SyntaxNode {
         closeBrace?: SyntaxToken;
     }, id: SyntaxNodeId, filepath: Filepath);
 }
-export declare class MetadataDeclarationNode extends SyntaxNode {
-    metadataKeyword?: SyntaxToken;
-    targetKind?: SyntaxToken;
-    targetName?: NormalExpressionNode;
-    bodyColon?: SyntaxToken;
-    body?: FunctionApplicationNode | BlockExpressionNode;
-    constructor({ metadataKeyword, targetKind, targetName, bodyColon, body, }: {
-        metadataKeyword?: SyntaxToken;
-        targetKind?: SyntaxToken;
-        targetName?: NormalExpressionNode;
-        bodyColon?: SyntaxToken;
-        body?: BlockExpressionNode | FunctionApplicationNode;
-    }, id: SyntaxNodeId, filepath: Filepath);
-    getTargetKind(): MetadataTargetKind | undefined;
-}
 export declare class ElementDeclarationNode extends SyntaxNode {
     type?: SyntaxToken;
+    targetKind?: SyntaxToken;
     name?: NormalExpressionNode;
     as?: SyntaxToken;
     alias?: NormalExpressionNode;
     attributeList?: ListExpressionNode;
     bodyColon?: SyntaxToken;
     body?: FunctionApplicationNode | BlockExpressionNode;
-    constructor({ type, name, as, alias, attributeList, bodyColon, body, }: {
+    constructor({ type, targetKind, name, as, alias, attributeList, bodyColon, body, }: {
         type?: SyntaxToken;
+        targetKind?: SyntaxToken;
         name?: NormalExpressionNode;
         as?: SyntaxToken;
         alias?: NormalExpressionNode;

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

@@ -1,7 +1,6 @@
 import { NONE_COLOR } from '../../constants';
 import { Filepath } from './filepath';
 import { Position } from './position';
-import { MetadataTargetKind } from './symbol';
 export type CustomMetadata = Record<string, string>;
 export type Color = `#${string}` | typeof NONE_COLOR;
 export declare enum AliasKind {
@@ -244,15 +243,10 @@ export interface TableRecord {
     values: RecordValue[][];
     token: TokenPosition;
 }
-export interface MetadataElement {
-    target: {
-        kind: MetadataTargetKind;
-        name: string[];
-    };
-    values: CustomMetadata;
-    valueTokens: Record<string, TokenPosition>;
+export type MetadataValues = Record<string, {
+    value: string;
     token: TokenPosition;
-}
+}>;
 export type Project = Record<string, never> | {
     name: string | null;
     tables: Table[];
@@ -267,4 +261,4 @@ export type Project = Record<string, never> | {
     token: TokenPosition;
     [index: string & Omit<any, 'name' | 'tables' | 'refs' | 'enums' | 'tableGroups' | 'note' | 'tablePartials' | 'records'>]: string;
 };
-export type SchemaElement = Database | Project | Table | Note | Column | ColumnType | Index | Check | InlineRef | Ref | RefEndpoint | Enum | EnumField | TableGroup | TableGroupField | Alias | TablePartial | TablePartialInjection | TableRecord | RecordValue | MetadataElement;
+export type SchemaElement = Database | Project | Table | Note | Column | ColumnType | Index | Check | InlineRef | Ref | RefEndpoint | Enum | EnumField | TableGroup | TableGroupField | Alias | TablePartial | TablePartialInjection | TableRecord | RecordValue | MetadataValues;

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

@@ -1,6 +1,6 @@
 import { default as Compiler } from '../../../compiler';
-import { AttributeNode, ElementDeclarationNode, MetadataDeclarationNode, SyntaxNode } from '../nodes';
-import { ColumnSymbol, NodeSymbol, TablePartialSymbol, TableSymbol } from '../symbol';
+import { AttributeNode, ElementDeclarationNode, SyntaxNode } from '../nodes';
+import { ColumnSymbol, NodeSymbol, ProgramSymbol, TablePartialSymbol, TableSymbol } from '../symbol';
 import { Internable } from '../internable';
 export declare enum MetadataKind {
     Ref = "ref",
@@ -27,7 +27,11 @@ export declare abstract class NodeMetadata implements Internable<InternedNodeMet
     constructor(declaration: SyntaxNode);
     intern(): InternedNodeMetadata;
     abstract owners(compiler: Compiler): NodeSymbol[];
-    reachableOwners(compiler: Compiler, targets: NodeSymbol[]): NodeSymbol[];
+    /** Get programs (source files) that can both
+      * - reach this metadata's declaration file and
+      * - see all the given target symbols in their nested schema.
+      */
+    resolveOwnerPrograms(compiler: Compiler, targets: NodeSymbol[]): ProgramSymbol[];
 }
 export declare class RefMetadata extends NodeMetadata {
     declaration: ElementDeclarationNode | AttributeNode;
@@ -76,9 +80,9 @@ export declare class RecordsMetadata extends NodeMetadata {
     owners(compiler: Compiler): NodeSymbol[];
 }
 export declare class MetadataElementMetadata extends NodeMetadata {
-    declaration: MetadataDeclarationNode;
+    declaration: ElementDeclarationNode;
     readonly kind = MetadataKind.MetadataElement;
-    constructor(declaration: MetadataDeclarationNode);
+    constructor(declaration: ElementDeclarationNode);
     target(compiler: Compiler): NodeSymbol | undefined;
     owners(compiler: Compiler): NodeSymbol[];
 }

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

@@ -36,14 +36,13 @@ export declare const ImportKind: {
     Schema: SymbolKind;
 };
 export type ImportKind = (typeof ImportKind)[keyof typeof ImportKind];
+/** Allowed target element types for a Metadata element header */
 export declare enum MetadataTargetKind {
-    Table = "table",
-    Schema = "schema",
-    Column = "column",
-    TableGroup = "tablegroup",
-    Note = "note"
+    Table = "Table",
+    Column = "Column",
+    TableGroup = "TableGroup",
+    Note = "Note"
 }
-export declare const ALLOWED_METADATA_TARGET_KINDS: readonly MetadataTargetKind[];
 declare const __nodeSymbolBrand: unique symbol;
 export type NodeSymbolId = number & {
     readonly [__nodeSymbolBrand]: true;
@@ -159,6 +158,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/span.d.ts

@@ -1,4 +1,4 @@
-import { ElementDeclarationNode, MetadataDeclarationNode, SyntaxNode } from '../types/nodes';
+import { ElementDeclarationNode, SyntaxNode } from '../types/nodes';
 import { SyntaxToken } from '../types/tokens';
 export declare function isOffsetWithinSpan(offset: number, nodeOrToken: SyntaxNode | SyntaxToken): boolean;
-export declare function isOffsetWithinElementHeader(offset: number, element: ElementDeclarationNode | MetadataDeclarationNode): boolean;
+export declare function isOffsetWithinElementHeader(offset: number, element: ElementDeclarationNode): boolean;

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

@@ -1,4 +1,3 @@
-import { CompileError, CompileErrorCode } from '../types/errors';
 import { AttributeNode, BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode, FunctionExpressionNode, InfixExpressionNode, ListExpressionNode, LiteralNode, PrefixExpressionNode, PrimaryExpressionNode, ProgramNode, SyntaxNode, TupleExpressionNode, UseDeclarationNode, UseSpecifierNode, VariableNode, WildcardNode } from '../types/nodes';
 import { default as Report } from '../types/report';
 import { SyntaxToken, SyntaxTokenKind } from '../types/tokens';
@@ -54,10 +53,6 @@ export declare function isTupleOfVariables(value?: SyntaxNode): value is TupleEx
 export declare function isValidColumnType(type: SyntaxNode): boolean;
 export type Settings = Record<SettingName | string, AttributeNode[]>;
 export declare function isValidMetadataValue(value?: SyntaxNode): boolean;
-export declare function validateCustomInlineMetadata(name: string, attrs: AttributeNode[], errorCodes: {
-    duplicate: CompileErrorCode;
-    invalidValue: CompileErrorCode;
-}): CompileError[];
 export declare function aggregateSettingList(settingList?: ListExpressionNode): Report<Settings>;
 export declare function isExpressionAQuotedString(value?: unknown): value is PrimaryExpressionNode & ({
     expression: VariableNode & {

package/dist/src/index.d.ts

@@ -10,7 +10,7 @@ export { SyntaxToken, SyntaxTokenKind, isTriviaToken, isOp, isOpToken, } from '.
 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 { 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 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, type CustomMetadata, } from './core/types/schemaJson';
 export type { DiagramViewSyncOperation, DiagramViewBlock, TextEdit, } from './compiler/queries/transform';
 export { dbmlLanguageConfig, dbmlMonarchTokensProvider, } from './services/monarch';
 export * from './compiler/projectLayout/layout';

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

@@ -1,5 +1,23 @@
 import { default as Compiler } from '../../compiler';
+import { SettingName } from '../../core/types/keywords';
 import { CompletionItemProvider, CompletionList, Position, TextModel } from '../types';
+export declare const COLUMN_TYPE_SUGGESTION_LABELS: readonly ["integer", "int", "tinyint", "smallint", "mediumint", "bigint", "bit", "bool", "binary", "varbinary", "logical", "char", "nchar", "varchar", "varchar2", "nvarchar", "nvarchar2", "binary_float", "binary_double", "float", "double", "decimal", "dec", "real", "money", "smallmoney", "enum", "tinyblob", "tinytext", "blob", "text", "mediumblob", "mediumtext", "longblob", "longtext", "ntext", "set", "inet6", "uuid", "image", "date", "time", "datetime", "datetime2", "timestamp", "year", "smalldatetime", "datetimeoffset", "XML", "sql_variant", "uniqueidentifier", "CURSOR", "BFILE", "CLOB", "NCLOB", "RAW"];
+export declare const TABLE_SETTING_SUGGESTION_LABELS: readonly [SettingName.HeaderColor, SettingName.Note];
+export declare const TABLE_SETTING_SUGGESTION_TEXT_INSERTS: string[];
+export declare const COLUMN_SUGGESTION_LABELS: (SettingName.Note | SettingName.PK | SettingName.PrimaryKey | SettingName.Unique | SettingName.Ref | SettingName.NotNull | SettingName.Null | SettingName.Increment | SettingName.Default | SettingName.Check)[];
+export declare const COLUMN_SUGGESTION_TEXT_INSERTS: string[];
+export declare const INDEX_SETTING_SUGGESTION_LABELS: (SettingName.Note | SettingName.PK | SettingName.Unique | SettingName.Name | SettingName.Type)[];
+export declare const INDEX_SETTING_SUGGESTION_TEXT_INSERTS: string[];
+export declare const REF_SETTING_SUGGESTION_LABELS: (SettingName.Color | SettingName.Update | SettingName.Delete | SettingName.Inactive)[];
+export declare const REF_SETTING_SUGGESTION_TEXT_INSERTS: string[];
+export declare const ENUM_SETTING_SUGGESTION_LABELS: readonly [SettingName.Note];
+export declare const ENUM_SETTING_SUGGESTION_TEXT_INSERTS: string[];
+export declare const CHECK_SETTING_SUGGESTION_LABELS: readonly [SettingName.Name];
+export declare const CHECK_SETTING_SUGGESTION_TEXT_INSERTS: string[];
+export declare const REF_ACTION_VALUE_SUGGESTIONS: readonly ["cascade", "set default", "set null", "restrict"];
+export declare const INDEX_TYPE_VALUE_SUGGESTIONS: readonly ["btree", "hash"];
+export declare const TABLE_BODY_SUGGESTION_LABELS: ("indexes" | "checks" | "Note" | "Records")[];
+export declare const PROJECT_FIELD_SUGGESTION_LABELS: ("Table" | "Enum" | "TableGroup" | "TablePartial" | "Note" | "Ref")[];
 export interface DBMLCompletionItemProviderOptions {
     triggerCharacters?: string[];
 }
@@ -9,3 +27,4 @@ export default class DBMLCompletionItemProvider implements CompletionItemProvide
     constructor(compiler: Compiler, options?: DBMLCompletionItemProviderOptions);
     provideCompletionItems(model: TextModel, position: Position): CompletionList;
 }
+export declare const TOP_LEVEL_SUGGESTION_LABELS: ("Table" | "Enum" | "TableGroup" | "TablePartial" | "Note" | "DiagramView" | "Metadata" | "Ref" | "Project" | "Records")[];

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@dbml/parse",
-  "version": "8.3.1-custom-metadata.2",
+  "version": "8.3.1-custom-metadata.4",
   "description": "DBML parser v2",
   "author": "Holistics <dev@holistics.io>",
   "license": "Apache-2.0",
@@ -50,5 +50,5 @@
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "6ab830c6b2387ff0c3c9cd0e94c52e62e722ca25"
+  "gitHead": "9b5601daf1b79ff7c96bc5766027447d1901c280"
 }

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

@@ -1,11 +0,0 @@
-import { SyntaxNode } from '../../types/nodes';
-import { Column, Note, Table, TableGroup, TokenPosition } from '../../types/schemaJson';
-import { SettingName } from '../../types';
-export type MetadataTarget = Table | TableGroup | Note | Column;
-export interface FieldValidateSpec {
-    predicate(valueNode?: SyntaxNode): boolean;
-    message: string;
-}
-export type FieldValidateMap<T extends SettingName = SettingName> = Record<T, FieldValidateSpec>;
-export type FieldAssign<T extends MetadataTarget> = (element: T, value: string, token: TokenPosition) => void;
-export type FieldAssignMap<T extends MetadataTarget = MetadataTarget, P extends SettingName = SettingName> = Record<P, FieldAssign<T>>;

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

@@ -1,4 +0,0 @@
-import { default as Compiler } from '../../../compiler/index';
-import { MetadataDeclarationNode } from '../../types/nodes';
-import { NodeSymbol } from '../../types/symbol';
-export declare function resolveMetadataTarget(compiler: Compiler, metadataNode: MetadataDeclarationNode): NodeSymbol | undefined;