@dbml/parse 8.3.1-custom-metadata.1 → 8.3.1-custom-metadata.3

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

@@ -0,0 +1,6 @@
+import { default as Compiler } from '../../../compiler/index';
+import { Filepath } from '../../types/filepath';
+import { NodeSymbol } from '../../types/symbol';
+import { MetadataFieldRegistry, MetadataTarget } from './metadataField';
+/** 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;

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

@@ -0,0 +1,4 @@
+import { MetadataTargetKind } from '../../types/symbol';
+import { MetadataFieldRegistry, MetadataTarget } from './metadataField';
+export declare const METADATA_FIELDS_BY_KIND: Record<MetadataTargetKind, MetadataFieldRegistry<any, any>>;
+export type { MetadataFieldRegistry, MetadataTarget };

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

@@ -1,23 +1,14 @@
 import { default as Compiler } from '../../../compiler';
 import { Filepath } from '../../types';
 import { MetadataElementMetadata } from '../../types/symbol/metadata';
-import { SyntaxNode } from '../../types/nodes';
 import { default as Report } from '../../types/report';
-import { Color, CustomMetadata, MetadataElement } from '../../types/schemaJson';
-import { Settings } from '../../utils/validate';
-export declare function extractValue(node?: SyntaxNode): string | number | boolean | Color | undefined;
-export declare const TABLE_BUILTIN_SETTINGS: readonly ["headercolor", "note"];
-export declare const TABLEGROUP_BUILTIN_SETTINGS: readonly ["color", "note"];
-export declare const NOTE_BUILTIN_SETTINGS: readonly ["color"];
-export declare const COLUMN_BUILTIN_SETTINGS: readonly ["pk", "primary key", "unique", "note", "ref", "default", "check", "increment", "not null", "null"];
-export declare function extractInlineMetadata(settingMap: Settings, builtinSettingNames: readonly string[]): CustomMetadata;
+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/metadataField.d.ts

@@ -0,0 +1,17 @@
+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;
+/**
+  * 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`)
+  */
+export 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>>;

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

@@ -1,4 +1,11 @@
 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;
+import { ElementDeclarationNode } from '../../types/nodes';
+import { NodeSymbol, SymbolKind, MetadataTargetKind } from '../../types/symbol';
+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;
+export {};

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

@@ -1,7 +1,9 @@
 import { Note } from '../../types/schemaJson';
 import { default as Compiler } from '../../../compiler';
-import { Filepath, NoteSymbol } from '../../types';
+import { SettingName, Filepath, NoteSymbol } from '../../types';
+import { MetadataFieldRegistry } from '../metadata/metadataField';
 import { default as Report } from '../../types/report';
+export declare const NOTE_METADATA_FIELDS: MetadataFieldRegistry<Note, SettingName.Color>;
 export declare class StickyNoteInterpreter {
     private declarationNode;
     private symbol;

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

@@ -11,17 +11,13 @@ 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 promoteOverlapKeys;
-    private attachMetadata;
     private interpretAllAliases;
     private validateRecords;
     private collectPartialRefs;
     private pushElement;
-    private recordEmitted;
 }

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

@@ -1,7 +1,9 @@
 import { default as Compiler } from '../../../compiler';
+import { SettingName } from '../../types/keywords';
 import { ElementDeclarationNode } from '../../types/nodes';
 import { default as Report } from '../../types/report';
-import { Table } from '../../types/schemaJson';
+import { Column, Table } from '../../types/schemaJson';
+import { MetadataFieldRegistry } from '../metadata/metadataField';
 import { Filepath } from '../../types/filepath';
 import { TableSymbol } from '../../types/symbol/symbols';
 export declare class TableInterpreter {
@@ -13,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;
@@ -24,3 +27,6 @@ export declare class TableInterpreter {
     private interpretIndexes;
     private interpretChecks;
 }
+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,7 +1,9 @@
 import { TableGroup } from '../../types/schemaJson';
 import { default as Compiler } from '../../../compiler';
-import { Filepath, TableGroupSymbol } from '../../types';
+import { SettingName, Filepath, TableGroupSymbol } from '../../types';
+import { MetadataFieldRegistry } from '../metadata/metadataField';
 import { default as Report } from '../../types/report';
+export declare const TABLEGROUP_METADATA_FIELDS: MetadataFieldRegistry<TableGroup, SettingName.Note | SettingName.Color>;
 export declare class TableGroupInterpreter {
     private compiler;
     private symbol;

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

@@ -114,11 +114,9 @@ export declare enum CompileErrorCode {
     UNEQUAL_FIELDS_BINARY_REF = 5003,
     CONFLICTING_SETTING = 5004,
     TABLE_REAPPEAR_IN_TABLEGROUP = 5005,
-    INVALID_METADATA_CONTEXT = 5006,
-    INVALID_METADATA_TARGET_KIND = 5007,
-    INVALID_METADATA_FIELD = 5008,
-    DUPLICATE_METADATA_FIELD = 5009,
-    METADATA_TARGET_NOT_FOUND = 5010
+    INVALID_METADATA_TARGET_KIND = 5006,
+    INVALID_METADATA_FIELD = 5007,
+    DUPLICATE_METADATA_FIELD = 5008
 }
 export declare class CompileError extends Error {
     code: Readonly<CompileErrorCode>;

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;
@@ -88,13 +86,11 @@ export declare class UseDeclarationNode extends SyntaxNode {
 }
 export declare class UseSpecifierNode extends SyntaxNode {
     importKind?: SyntaxToken;
-    subKind?: SyntaxToken;
     name?: NormalExpressionNode;
     asKeyword?: SyntaxToken;
     alias?: NormalExpressionNode;
-    constructor({ importKind, subKind, name, asKeyword, alias, }: {
+    constructor({ importKind, name, asKeyword, alias, }: {
         importKind?: SyntaxToken;
-        subKind?: SyntaxToken;
         name?: NormalExpressionNode;
         asKeyword?: SyntaxToken;
         alias?: NormalExpressionNode;
@@ -112,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,7 @@
 import { NONE_COLOR } from '../../constants';
 import { Filepath } from './filepath';
 import { Position } from './position';
-export type CustomMetadata = Record<string, unknown>;
+export type CustomMetadata = Record<string, string>;
 export type Color = `#${string}` | typeof NONE_COLOR;
 export declare enum AliasKind {
     Table = "table"
@@ -243,15 +243,10 @@ export interface TableRecord {
     values: RecordValue[][];
     token: TokenPosition;
 }
-export interface MetadataElement {
-    target: {
-        kind: string;
-        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[];
@@ -266,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

@@ -34,17 +34,15 @@ export declare const ImportKind: {
     TablePartial: SymbolKind;
     Note: SymbolKind;
     Schema: SymbolKind;
-    Metadata: 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;
@@ -160,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/interpret.d.ts

@@ -1,7 +1,9 @@
 import { default as Compiler } from '../../compiler';
-import { Color, ColumnType, TokenPosition } from '../types/schemaJson';
+import { Color, ColumnType, CustomMetadata, TokenPosition } from '../types/schemaJson';
 import { SyntaxNode } from '../types/nodes';
 import { default as Report } from '../types/report';
+import { Settings } from './validate';
+import { SettingName } from '../types';
 export declare function getTokenPosition(node: SyntaxNode): TokenPosition;
 export declare function normalizeNote(content: string): string;
 export declare function extractElementName(nameNode: SyntaxNode): {
@@ -14,3 +16,11 @@ export declare function processDefaultValue(valueNode?: SyntaxNode): {
     value: string | number;
 } | undefined;
 export declare function processColumnType(compiler: Compiler, typeNode: SyntaxNode): Report<ColumnType>;
+/**
+  * Extract inline custom metadata from an aggregated setting list,
+  * excluding keys that are natively attached to the element (headercolor and note in `table`, color in `tablegroup`, .etc).
+  *
+  * NOTE: This is used during interpret phase, so no need to validate values, just extract them
+  */
+export declare function extractCustomInlineMetadata(settingMap: Settings, builtinSettings: readonly SettingName[]): CustomMetadata;
+export declare function extractMetadataValue(node?: SyntaxNode): string | Color | undefined;

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 validateInlineMetadataSetting(name: string, attrs: AttributeNode[], codes: {
-    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/package.json

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

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

@@ -1,14 +0,0 @@
-import { MetadataTargetKind } from '../../types/symbol';
-export declare enum OverlapValueKind {
-    Note = "note",
-    Color = "color",
-    HeaderColor = "headercolor"
-}
-export type OverlapInlineField = 'note' | 'color' | 'headerColor';
-export interface OverlapKey {
-    metaKey: string;
-    field: OverlapInlineField;
-    reshape: OverlapValueKind;
-}
-export declare const OVERLAP_KEYS: Partial<Record<MetadataTargetKind, OverlapKey[]>>;
-export declare function findOverlapKey(kind: MetadataTargetKind | undefined, key: string): OverlapKey | undefined;