@dbml/parse 10.0.0-optional-ref.0 → 10.0.0

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

@@ -57,64 +57,73 @@ export declare enum CompileErrorCode {
     INVALID_REF_FIELD = 3039,
     EMPTY_REF = 3040,
     REF_REDEFINED = 3041,
-    INVALID_NOTE_CONTEXT = 3042,
-    INVALID_NOTE = 3043,
-    NOTE_REDEFINED = 3044,
-    NOTE_CONTENT_REDEFINED = 3045,
-    EMPTY_NOTE = 3046,
-    UNKNOWN_NOTE_SETTING = 3047,
-    DUPLICATE_NOTE_SETTING = 3048,
-    INVALID_NOTE_SETTING_VALUE = 3049,
-    INVALID_INDEXES_CONTEXT = 3050,
-    INVALID_INDEXES_FIELD = 3051,
-    INVALID_INDEX = 3052,
-    UNKNOWN_INDEX_SETTING = 3053,
-    DUPLICATE_INDEX_SETTING = 3054,
-    UNEXPECTED_INDEX_SETTING_VALUE = 3055,
-    INVALID_INDEX_SETTING_VALUE = 3056,
-    INVALID_PROJECT_CONTEXT = 3057,
-    PROJECT_REDEFINED = 3058,
-    INVALID_PROJECT_FIELD = 3059,
-    INVALID_CUSTOM_CONTEXT = 3060,
-    INVALID_CUSTOM_ELEMENT_VALUE = 3061,
-    INVALID_ELEMENT_IN_SIMPLE_BODY = 3062,
-    INVALID_TABLE_PARTIAL_CONTEXT = 3063,
-    INVALID_TABLE_PARTIAL_ELEMENT_NAME = 3064,
-    INVALID_TABLE_PARTIAL_SETTING_VALUE = 3065,
-    DUPLICATE_TABLE_PARTIAL_ELEMENT_NAME = 3066,
-    DUPLICATE_TABLE_PARTIAL_SETTING = 3067,
-    INVALID_TABLE_PARTIAL_INJECTION = 3068,
-    INVALID_TABLE_PARTIAL_INJECTION_OP = 3069,
-    INVALID_TABLE_PARTIAL_INJECTION_NAME = 3070,
-    DUPLICATE_TABLE_PARTIAL_INJECTION_NAME = 3071,
-    UNKNOWN_TABLE_PARTIAL_SETTING = 3072,
-    INVALID_TABLE_SETTING_VALUE = 3073,
-    INVALID_CHECKS_CONTEXT = 3074,
-    INVALID_CHECKS_FIELD = 3075,
-    INVALID_CHECK = 3076,
-    UNKNOWN_CHECK_SETTING = 3077,
-    DUPLICATE_CHECK_SETTING = 3078,
-    INVALID_CHECK_SETTING_VALUE = 3079,
-    INVALID_RECORDS_CONTEXT = 3080,
-    INVALID_RECORDS_NAME = 3081,
-    INVALID_RECORDS_FIELD = 3082,
-    DUPLICATE_COLUMN_REFERENCES_IN_RECORDS = 3083,
-    DUPLICATE_RECORDS_FOR_TABLE = 3084,
-    INVALID_USE_CONTEXT = 3085,
-    INVALID_USE_SPECIFIER_KIND = 3086,
-    INVALID_USE_SPECIFIER_NAME = 3087,
-    INVALID_DIAGRAMVIEW_CONTEXT = 3088,
-    DUPLICATE_DIAGRAMVIEW_NAME = 3089,
-    INVALID_DIAGRAMVIEW_FIELD = 3090,
-    DUPLICATE_DIAGRAMVIEW_FIELD = 3091,
+    INVALID_DEP_CONTEXT = 3042,
+    INVALID_DEP_FIELD = 3043,
+    INVALID_NOTE_CONTEXT = 3044,
+    INVALID_NOTE = 3045,
+    NOTE_REDEFINED = 3046,
+    NOTE_CONTENT_REDEFINED = 3047,
+    EMPTY_NOTE = 3048,
+    UNKNOWN_NOTE_SETTING = 3049,
+    DUPLICATE_NOTE_SETTING = 3050,
+    INVALID_NOTE_SETTING_VALUE = 3051,
+    INVALID_INDEXES_CONTEXT = 3052,
+    INVALID_INDEXES_FIELD = 3053,
+    INVALID_INDEX = 3054,
+    UNKNOWN_INDEX_SETTING = 3055,
+    DUPLICATE_INDEX_SETTING = 3056,
+    UNEXPECTED_INDEX_SETTING_VALUE = 3057,
+    INVALID_INDEX_SETTING_VALUE = 3058,
+    INVALID_PROJECT_CONTEXT = 3059,
+    PROJECT_REDEFINED = 3060,
+    INVALID_PROJECT_FIELD = 3061,
+    INVALID_CUSTOM_CONTEXT = 3062,
+    INVALID_CUSTOM_ELEMENT_VALUE = 3063,
+    INVALID_ELEMENT_IN_SIMPLE_BODY = 3064,
+    INVALID_TABLE_PARTIAL_CONTEXT = 3065,
+    INVALID_TABLE_PARTIAL_ELEMENT_NAME = 3066,
+    INVALID_TABLE_PARTIAL_SETTING_VALUE = 3067,
+    DUPLICATE_TABLE_PARTIAL_ELEMENT_NAME = 3068,
+    DUPLICATE_TABLE_PARTIAL_SETTING = 3069,
+    INVALID_TABLE_PARTIAL_INJECTION = 3070,
+    INVALID_TABLE_PARTIAL_INJECTION_OP = 3071,
+    INVALID_TABLE_PARTIAL_INJECTION_NAME = 3072,
+    DUPLICATE_TABLE_PARTIAL_INJECTION_NAME = 3073,
+    UNKNOWN_TABLE_PARTIAL_SETTING = 3074,
+    INVALID_TABLE_SETTING_VALUE = 3075,
+    INVALID_CHECKS_CONTEXT = 3076,
+    INVALID_CHECKS_FIELD = 3077,
+    INVALID_CHECK = 3078,
+    UNKNOWN_CHECK_SETTING = 3079,
+    DUPLICATE_CHECK_SETTING = 3080,
+    INVALID_CHECK_SETTING_VALUE = 3081,
+    INVALID_RECORDS_CONTEXT = 3082,
+    INVALID_RECORDS_NAME = 3083,
+    INVALID_RECORDS_FIELD = 3084,
+    DUPLICATE_COLUMN_REFERENCES_IN_RECORDS = 3085,
+    DUPLICATE_RECORDS_FOR_TABLE = 3086,
+    INVALID_USE_CONTEXT = 3087,
+    INVALID_USE_SPECIFIER_KIND = 3088,
+    INVALID_USE_SPECIFIER_NAME = 3089,
+    INVALID_DIAGRAMVIEW_CONTEXT = 3090,
+    DUPLICATE_DIAGRAMVIEW_NAME = 3091,
+    INVALID_DIAGRAMVIEW_FIELD = 3092,
+    DUPLICATE_DIAGRAMVIEW_FIELD = 3093,
     BINDING_ERROR = 4000,
     NONEXISTENT_MODULE = 4001,
     UNSUPPORTED = 5000,
     CIRCULAR_REF = 5001,
     SAME_ENDPOINT = 5002,
-    UNEQUAL_FIELDS_BINARY_REF = 5003,
-    CONFLICTING_SETTING = 5004,
-    TABLE_REAPPEAR_IN_TABLEGROUP = 5005
+    DEP_SELF_LOOP = 5003,
+    DEP_MIXED_DOWNSTREAM_TABLES = 5004,
+    DEP_DUPLICATE_DOWNSTREAM_TABLE = 5005,
+    DEP_MIXED_LEVEL = 5006,
+    UNEQUAL_FIELDS_BINARY_REF = 5007,
+    CONFLICTING_SETTING = 5008,
+    TABLE_REAPPEAR_IN_TABLEGROUP = 5009,
+    INVALID_METADATA_TARGET_KIND = 5010,
+    INVALID_METADATA_FIELD = 5011,
+    DUPLICATE_METADATA_FIELD = 5012
 }
 export interface RelatedLocation {
     nodeOrToken: SyntaxNode | SyntaxToken;

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

@@ -2,6 +2,7 @@ export declare enum ElementKind {
     Table = "table",
     Enum = "enum",
     Ref = "ref",
+    Dep = "dep",
     Note = "note",
     Project = "project",
     Indexes = "indexes",
@@ -13,7 +14,8 @@ export declare enum ElementKind {
     DiagramViewTables = "tables",
     DiagramViewNotes = "notes",
     DiagramViewTableGroups = "tablegroups",
-    DiagramViewSchemas = "schemas"
+    DiagramViewSchemas = "schemas",
+    Metadata = "metadata"
 }
 export declare enum SettingName {
     Color = "color",
@@ -23,6 +25,7 @@ export declare enum SettingName {
     PrimaryKey = "primary key",
     Unique = "unique",
     Ref = "ref",
+    Dep = "dep",
     NotNull = "not null",
     Null = "null",
     Increment = "increment",

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

@@ -110,14 +110,16 @@ export declare class UseSpecifierListNode extends SyntaxNode {
 }
 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;
@@ -125,8 +127,17 @@ export declare class ElementDeclarationNode extends SyntaxNode {
         bodyColon?: SyntaxToken;
         body?: BlockExpressionNode | FunctionApplicationNode;
     }, id: SyntaxNodeId, filepath: Filepath);
-    isKind(...kinds: ElementKind[]): boolean;
-    getElementKind(): ElementKind | undefined;
+    isKind<T extends ElementKind>(...kinds: T[]): this is ElementDeclarationNode & {
+        type: {
+            value: T;
+        };
+    };
+    getElementKind<T extends ElementKind>(this: ElementDeclarationNode & {
+        type: {
+            value: T;
+        };
+    }): T;
+    getElementKind(this: ElementDeclarationNode): ElementKind | undefined;
 }
 export declare class IdentifierStreamNode extends SyntaxNode {
     identifiers: SyntaxToken[];

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

@@ -1,17 +1,21 @@
 type BaseRelationshipOp = '>' | '<' | '-' | '<>';
 export type RelationshipOp = `${'?' | ''}${BaseRelationshipOp}${'?' | ''}`;
 export type RelationCardinality = `${number}` | '*' | `${number}..${number | '*'}`;
-export declare function normalizeCardinality(c: RelationCardinality): RelationCardinality;
 export declare function parseCardinality(c: RelationCardinality): {
     min: number;
     max: number | '*';
 };
-export declare const RELATIONSHIP_OPS: ReadonlySet<RelationshipOp>;
 export declare const CARDINALITY_ONE: RelationCardinality;
 export declare const CARDINALITY_MAYBE: RelationCardinality;
 export declare const CARDINALITY_SOME: RelationCardinality;
 export declare const CARDINALITY_MANY: RelationCardinality;
+export declare const RELATIONSHIP_OPS: ReadonlyMap<RelationshipOp, [RelationCardinality, RelationCardinality]>;
 export declare function getMultiplicities(op: string): [RelationCardinality, RelationCardinality] | undefined;
+export declare function isEndpointOneSide(relation: RelationCardinality): boolean;
+export declare function isEndpointManySide(relation: RelationCardinality): boolean;
+export declare function isEndpointOptional(relation: RelationCardinality): boolean;
+export declare function isEndpointRequired(relation: RelationCardinality): boolean;
+export declare function makeRelationshipRequired(op: RelationshipOp): BaseRelationshipOp;
 export declare function getRelationshipOp(left: RelationCardinality, right: RelationCardinality): RelationshipOp;
 export declare function makeCardinalityOptional(rel: RelationCardinality): RelationCardinality;
 export declare function makeCardinalityRequired(rel: RelationCardinality): RelationCardinality;

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

@@ -2,6 +2,7 @@ import { NONE_COLOR } from '../../../constants';
 import { Filepath } from '../filepath';
 import { Position } from '../position';
 import { RelationshipOp, RelationCardinality } from '../relation';
+export type CustomMetadata = Record<string, string>;
 export type Color = `#${string}` | typeof NONE_COLOR;
 export declare enum AliasKind {
     Table = "table"
@@ -59,6 +60,7 @@ export interface Database {
     tables: Table[];
     notes: Note[];
     refs: Ref[];
+    deps: Dep[];
     enums: Enum[];
     tableGroups: TableGroup[];
     aliases: Alias[];
@@ -86,12 +88,14 @@ export interface Table {
         value: string;
         token: TokenPosition;
     };
+    metadata?: CustomMetadata;
 }
 export interface Note {
     name: string;
     content: string;
     token: TokenPosition;
     color?: Color;
+    metadata?: CustomMetadata;
 }
 export interface ColumnType {
     schemaName: string | null;
@@ -111,6 +115,7 @@ export interface Column {
     type: ColumnType;
     token: TokenPosition;
     inline_refs: InlineRef[];
+    inline_deps: InlineDep[];
     checks: Check[];
     pk?: boolean;
     dbdefault?: {
@@ -124,6 +129,7 @@ export interface Column {
         value: string;
         token: TokenPosition;
     };
+    metadata?: CustomMetadata;
 }
 export interface Index {
     columns: {
@@ -171,6 +177,39 @@ export interface RefEndpoint {
     relation: RelationCardinality;
     token: TokenPosition;
 }
+export interface Dep {
+    schemaName: string | null;
+    name: string | null;
+    edges: DepEdge[];
+    color?: Color;
+    note?: {
+        value: string;
+        token: TokenPosition;
+    };
+    metadata?: Record<string, string | number | boolean | null>;
+    token: TokenPosition;
+}
+export interface DepEdge {
+    upstream: DepEndpoint;
+    downstream: DepEndpoint;
+    token: TokenPosition;
+}
+export interface DepEndpoint {
+    schemaName: string | null;
+    tableName: string;
+    fieldNames: string[];
+    token: TokenPosition;
+}
+export declare const DEP_DOWNSTREAM: "->";
+export declare const DEP_UPSTREAM: "<-";
+export type DepDirection = typeof DEP_DOWNSTREAM | typeof DEP_UPSTREAM;
+export interface InlineDep {
+    schemaName: string | null;
+    tableName: string;
+    fieldNames: string[];
+    direction: DepDirection;
+    token: TokenPosition;
+}
 export interface Enum {
     name: string;
     schemaName: string | null;
@@ -195,6 +234,7 @@ export interface TableGroup {
         value: string;
         token: TokenPosition;
     };
+    metadata?: CustomMetadata;
 }
 export interface TableGroupField {
     name: string;
@@ -238,6 +278,10 @@ export interface TableRecord {
     values: RecordValue[][];
     token: TokenPosition;
 }
+export type MetadataValues = Record<string, {
+    value: string;
+    token: TokenPosition;
+}>;
 export type Project = Record<string, never> | {
     name: string | null;
     tables: Table[];
@@ -252,4 +296,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;
+export type SchemaElement = Database | Project | Table | Note | Column | ColumnType | Index | Check | InlineRef | InlineDep | Ref | RefEndpoint | Dep | DepEdge | DepEndpoint | Enum | EnumField | TableGroup | TableGroupField | Alias | TablePartial | TablePartialInjection | TableRecord | RecordValue | MetadataValues;

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

@@ -1,16 +1,18 @@
 import { default as Compiler } from '../../../compiler';
-import { AttributeNode, ElementDeclarationNode, SyntaxNode } from '../nodes';
+import { AttributeNode, ElementDeclarationNode, InfixExpressionNode, SyntaxNode } from '../nodes';
 import { SyntaxToken } from '../tokens';
-import { ColumnSymbol, NodeSymbol, TablePartialSymbol, TableSymbol } from '../symbol';
+import { ColumnSymbol, NodeSymbol, ProgramSymbol, TablePartialSymbol, TableSymbol } from '../symbol';
 import { Internable } from '../internable';
 import { RelationshipOp, RelationCardinality } from '../relation';
 export declare enum MetadataKind {
     Ref = "ref",
+    Dep = "dep",
     PartialRef = "partial ref",
     TableChecks = "table checks",
     Indexes = "indexes",
     Records = "records",
-    Project = "project"
+    Project = "project",
+    MetadataElement = "metadata element"
 }
 declare const __nodeMetadataBrand: unique symbol;
 export type NodeMetadataId = number & {
@@ -28,6 +30,11 @@ export declare abstract class NodeMetadata implements Internable<InternedNodeMet
     constructor(declaration: SyntaxNode);
     intern(): InternedNodeMetadata;
     abstract owners(compiler: Compiler): 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;
@@ -54,6 +61,19 @@ export declare class RefMetadata extends NodeMetadata {
     rightToken(): SyntaxNode;
     owners(compiler: Compiler): NodeSymbol[];
 }
+export declare class DepMetadata extends NodeMetadata {
+    declaration: ElementDeclarationNode | AttributeNode;
+    readonly kind = MetadataKind.Dep;
+    constructor(declaration: ElementDeclarationNode | AttributeNode);
+    container(compiler: Compiler): TableSymbol | undefined;
+    edgeExpressions(): InfixExpressionNode[];
+    upstreamColumns(compiler: Compiler): ColumnSymbol[][];
+    downstreamColumns(compiler: Compiler): ColumnSymbol[][];
+    upstreamTables(compiler: Compiler): (TableSymbol | undefined)[];
+    downstreamTables(compiler: Compiler): (TableSymbol | undefined)[];
+    private hostColumn;
+    owners(compiler: Compiler): NodeSymbol[];
+}
 export declare class PartialRefMetadata extends NodeMetadata {
     readonly kind = MetadataKind.PartialRef;
     constructor(declaration: SyntaxNode);
@@ -65,14 +85,6 @@ export declare class PartialRefMetadata extends NodeMetadata {
     op(_compiler: Compiler): RelationshipOp | undefined;
     opToken(): SyntaxToken | undefined;
     cardinalities(compiler: Compiler): [RelationCardinality, RelationCardinality] | undefined;
-    leftCardinality(compiler: Compiler): {
-        min: number;
-        max: number | '*';
-    } | undefined;
-    rightCardinality(compiler: Compiler): {
-        min: number;
-        max: number | '*';
-    } | undefined;
     leftToken(): SyntaxNode;
     rightToken(): SyntaxNode;
     owners(compiler: Compiler): NodeSymbol[];
@@ -95,6 +107,13 @@ export declare class RecordsMetadata extends NodeMetadata {
     table(compiler: Compiler): TableSymbol | undefined;
     owners(compiler: Compiler): NodeSymbol[];
 }
+export declare class MetadataElementMetadata extends NodeMetadata {
+    declaration: ElementDeclarationNode;
+    readonly kind = MetadataKind.MetadataElement;
+    constructor(declaration: ElementDeclarationNode);
+    target(compiler: Compiler): NodeSymbol | undefined;
+    owners(compiler: Compiler): NodeSymbol[];
+}
 export declare class ProjectMetadata extends NodeMetadata {
     readonly kind = MetadataKind.Project;
     constructor(declaration: SyntaxNode);

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

@@ -24,6 +24,7 @@ export declare enum SymbolKind {
     DiagramViewTableGroup = "DiagramView tablegroup",
     DiagramViewNote = "DiagramView note",
     DiagramViewSchema = "DiagramView schema",
+    Metadata = "Metadata",
     Program = "Program"
 }
 export declare const ImportKind: {
@@ -35,6 +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",
+    Column = "Column",
+    TableGroup = "TableGroup",
+    Note = "Note"
+}
 declare const __nodeSymbolBrand: unique symbol;
 export type NodeSymbolId = number & {
     readonly [__nodeSymbolBrand]: true;
@@ -147,11 +155,12 @@ export declare class ColumnSymbol extends NodeSymbol {
     }, id: NodeSymbolId, filepath: Filepath);
     get canBeImported(): boolean;
     get originalSymbol(): NodeSymbol;
-    qualifiedName(compiler: Compiler): string;
+    qualifiedName(compiler: Compiler): string[];
     pk(compiler: Compiler): boolean;
     isUniqueSet(compiler: Compiler): boolean;
     unique(compiler: Compiler): boolean;
     nullable(compiler: Compiler): boolean;
+    private isInPkIndex;
     isNotNullSet(compiler: Compiler): boolean | undefined;
     isIncrementSet(compiler: Compiler): boolean;
     increment(compiler: Compiler): boolean;

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

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

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

@@ -1,16 +1,26 @@
 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): {
     schemaName: string[];
     name: string;
 };
-export declare function extractColor(node: unknown): Color | undefined;
+export declare function extractColor(node?: SyntaxNode): Color | undefined;
 export declare function processDefaultValue(valueNode?: SyntaxNode): {
     type: 'number' | 'string' | 'boolean' | 'expression';
     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/note.d.ts

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

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

@@ -1,17 +1,16 @@
-import { SyntaxNode } from '../types/nodes';
+import { ListExpressionNode, AttributeNode, ElementDeclarationNode, SyntaxNode } from '../types/nodes';
 import { TextEdit } from '../../compiler/queries/transform/applyTextEdits';
-/**
- * Produces a TextEdit that adds a setting to a field/element declaration.
- * If the declaration already has a settings block [...], inserts before the closing ].
- * Otherwise, appends a new [setting] block.
- */
+export type SettingLocation = {
+    kind: 'attribute';
+    settingsList: ListExpressionNode;
+    settingNode: AttributeNode;
+    settingIndex: number;
+} | {
+    kind: 'body';
+    declaration: ElementDeclarationNode;
+} | undefined;
+export declare function findSetting(declaration: SyntaxNode, settingName: string): SettingLocation;
 export declare function addSettingEdit(declaration: SyntaxNode, setting: string): TextEdit | undefined;
-/**
- * Produces a TextEdit that updates an existing setting's value in a declaration.
- */
-export declare function updateSettingEdit(declaration: SyntaxNode, settingName: string, newValue: string, source: string): TextEdit | undefined;
-/**
- * Produces a TextEdit that removes a setting from a declaration.
- * If it's the only setting, removes the entire settings block [...].
- */
+export declare function updateSettingEdit(declaration: SyntaxNode, settingName: string, value: string | null | undefined, source: string): TextEdit | undefined;
 export declare function removeSettingEdit(declaration: SyntaxNode, settingName: string, source: string): TextEdit | undefined;
+export declare function findBodySetting(declaration: ElementDeclarationNode, settingName: string): ElementDeclarationNode | undefined;

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

@@ -6,6 +6,9 @@ export declare function isAsKeyword(token?: SyntaxToken): token is SyntaxToken &
 export declare function isUseKeyword(token?: SyntaxToken): token is SyntaxToken & {
     kind: SyntaxTokenKind.IDENTIFIER;
 };
+export declare function isMetadataKeyword(token?: SyntaxToken): token is SyntaxToken & {
+    kind: SyntaxTokenKind.IDENTIFIER;
+};
 export declare function isFromKeyword(token?: SyntaxToken): token is SyntaxToken & {
     kind: SyntaxTokenKind.IDENTIFIER;
 };

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

@@ -24,7 +24,15 @@ export declare function isValidPartialInjection(node?: SyntaxNode): node is Pref
     };
 };
 export declare function isRelationshipOp(op?: string): boolean;
-export declare function isValidColor(value?: SyntaxNode): boolean;
+export declare function isDependencyOp(op?: string): boolean;
+export declare function isValidHexColor(value?: SyntaxNode): value is PrimaryExpressionNode & {
+    expression: LiteralNode & {
+        literal: {
+            kind: SyntaxTokenKind.COLOR_LITERAL;
+        };
+    };
+};
+export declare function isValidColorOrNone(value?: SyntaxNode): boolean;
 export declare function isValidDefaultValue(value?: SyntaxNode): boolean;
 export type SignedNumberExpression = (PrimaryExpressionNode & {
     expression: LiteralNode & {
@@ -38,6 +46,7 @@ export type SignedNumberExpression = (PrimaryExpressionNode & {
 });
 export declare function isExpressionASignedNumberExpression(value?: SyntaxNode): value is SignedNumberExpression;
 export declare function isUnaryRelationship(value?: SyntaxNode): value is PrefixExpressionNode;
+export declare function isUnaryDependency(value?: SyntaxNode): value is PrefixExpressionNode;
 export declare function isTupleOfVariables(value?: SyntaxNode): value is TupleExpressionNode & {
     elementList: (PrimaryExpressionNode & {
         expression: VariableNode;
@@ -45,6 +54,7 @@ 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 aggregateSettingList(settingList?: ListExpressionNode): Report<Settings>;
 export declare function isExpressionAQuotedString(value?: unknown): value is PrimaryExpressionNode & ({
     expression: VariableNode & {
@@ -84,7 +94,11 @@ type DotDelimitedIdentifier = PrimaryExpressionNode | (AccessExpression & {
 });
 export declare function isAccessExpression(node?: SyntaxNode): node is AccessExpression;
 export declare function isDotDelimitedIdentifier(node?: SyntaxNode): node is DotDelimitedIdentifier;
-export declare function isElementNode(node: SyntaxNode | undefined, kind: ElementKind): node is ElementDeclarationNode;
+export declare function isElementNode<T extends ElementKind>(node: SyntaxNode | undefined, kind: T): node is ElementDeclarationNode & {
+    type: {
+        value: T;
+    };
+};
 export declare function isUseDeclaration(node: SyntaxNode): node is UseDeclarationNode;
 export declare function isUseSpecifier(node: SyntaxNode, kind?: ImportKind): node is UseSpecifierNode;
 export declare function isWildcardSpecifier(node: SyntaxNode): node is WildcardNode;

package/dist/src/index.d.ts

@@ -4,15 +4,19 @@ export { Filepath } from './core/types/filepath';
 export { UNHANDLED, type Unhandled, } from './core/types/module';
 export { ElementKind } from './core/types/keywords';
 export { type NodeSymbol, SymbolKind, } from './core/types/symbol';
+export { MetadataKind } from './core/types/symbol/metadata';
 export * from './core/global_modules/records/utils';
 export * from './core/types/nodes';
 export { SyntaxToken, SyntaxTokenKind, isTriviaToken, isOp, isOpToken, } from './core/types/tokens';
 export { CompileError, CompileErrorCode, } from './core/types/errors';
 export type { Position, } from './core/types';
-export { ScopeKind, splitQualifiedIdentifier, unescapeString, escapeString, formatRecordValue, isValidIdentifier, addDoubleQuoteIfNeeded, } from './compiler/index';
-export { 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 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 RelationCardinality, type RelationshipOp, getRelationshipOp, getMultiplicities, parseCardinality, makeCardinalityRequired, makeCardinalityOptional, CARDINALITY_ONE, CARDINALITY_MAYBE, CARDINALITY_SOME, CARDINALITY_MANY, } from './core/types/relation';
+export { ScopeKind, splitQualifiedIdentifier, unescapeString, escapeString, formatRecordValue, isValidIdentifier, addDoubleQuoteIfNeeded, normalizeQualifiedName, } from './compiler/index';
+export { type Database, type MasterDatabase, type Table, type Note, type Column, type ColumnType, type Index, type Check, type InlineRef, type Ref, type RefEndpointPair, type RefEndpoint, type 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 RelationCardinality, type RelationshipOp, getRelationshipOp, getMultiplicities, parseCardinality, makeCardinalityRequired, makeCardinalityOptional, makeRelationshipRequired, isEndpointOneSide, isEndpointManySide, isEndpointOptional, isEndpointRequired, CARDINALITY_ONE, CARDINALITY_MAYBE, CARDINALITY_SOME, CARDINALITY_MANY, } from './core/types/relation';
 export type { DiagramViewSyncOperation, DiagramViewBlock, TextEdit, } from './compiler/queries/transform';
+export { findDiagramViewBlocks, findDepBlocks } from './compiler/queries/transform';
+export type { DepSyncOperation, DepSyncEdge, DepEndpointRef, DepBlock, } from './compiler/queries/transform';
+export type { ElementIdentifier, SchemaIdentifier, TableIdentifier, ColumnIdentifier, EnumIdentifier, EndpointRef, RefIdentifier, DepIdentifier, NoteIdentifier, TableGroupIdentifier, } from './compiler/queries/transform';
 export { dbmlLanguageConfig, dbmlMonarchTokensProvider, } from './services/monarch';
 export * from './compiler/projectLayout/layout';
 export { Compiler };

package/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.Dep | 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" | "Dep")[];
 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" | "Dep" | "Project" | "Records")[];