@dbml/parse 8.3.1-custom-metadata.2 → 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,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/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,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 { 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;
@@ -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,7 +3,7 @@ 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 { MetadataFieldRegistry } from '../metadata/metadataField';
 import { Filepath } from '../../types/filepath';
 import { TableSymbol } from '../../types/symbol/symbols';
 export declare class TableInterpreter {
@@ -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,6 @@ 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>;
+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 { 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;
@@ -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/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.3",
   "description": "DBML parser v2",
   "author": "Holistics <dev@holistics.io>",
   "license": "Apache-2.0",
@@ -50,5 +50,5 @@
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "6ab830c6b2387ff0c3c9cd0e94c52e62e722ca25"
+  "gitHead": "be8c21d3525b0001b295695af7057e0e9cfae5d1"
 }

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>>;