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

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

@@ -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/compiler/types.d.ts

@@ -11,6 +11,5 @@ export declare const enum ScopeKind {
     TABLEPARTIAL = 9,
     CHECKS = 10,
     RECORDS = 11,
-    DIAGRAMVIEW = 12,
-    METADATA = 13
+    DIAGRAMVIEW = 12
 }

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

@@ -1,5 +1,5 @@
 import { default as Compiler } from '../../compiler';
-import { Filepath, RelationCardinality } from '../types';
+import { RelationCardinality } from '../types';
 import { PrimaryExpressionNode, SyntaxNode, VariableNode } from '../types/nodes';
 import { default as Report } from '../types/report';
 import { NodeSymbol } from '../types/symbol';
@@ -15,5 +15,3 @@ 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;

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

@@ -113,12 +113,7 @@ export declare enum CompileErrorCode {
     SAME_ENDPOINT = 5002,
     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
+    TABLE_REAPPEAR_IN_TABLEGROUP = 5005
 }
 export declare class CompileError extends Error {
     code: Readonly<CompileErrorCode>;

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

@@ -13,8 +13,7 @@ export declare enum ElementKind {
     DiagramViewTables = "tables",
     DiagramViewNotes = "notes",
     DiagramViewTableGroups = "tablegroups",
-    DiagramViewSchemas = "schemas",
-    Metadata = "metadata"
+    DiagramViewSchemas = "schemas"
 }
 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;
@@ -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,21 +108,6 @@ 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;
     name?: NormalExpressionNode;
@@ -144,17 +125,8 @@ export declare class ElementDeclarationNode extends SyntaxNode {
         bodyColon?: SyntaxToken;
         body?: BlockExpressionNode | FunctionApplicationNode;
     }, id: SyntaxNodeId, filepath: Filepath);
-    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;
+    isKind(...kinds: ElementKind[]): boolean;
+    getElementKind(): ElementKind | undefined;
 }
 export declare class IdentifierStreamNode extends SyntaxNode {
     identifiers: SyntaxToken[];

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';
-export type CustomMetadata = Record<string, unknown>;
 export type Color = `#${string}` | typeof NONE_COLOR;
 export declare enum AliasKind {
     Table = "table"
@@ -86,14 +85,12 @@ 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;
@@ -126,7 +123,6 @@ export interface Column {
         value: string;
         token: TokenPosition;
     };
-    metadata?: CustomMetadata;
 }
 export interface Index {
     columns: {
@@ -199,7 +195,6 @@ export interface TableGroup {
         value: string;
         token: TokenPosition;
     };
-    metadata?: CustomMetadata;
 }
 export interface TableGroupField {
     name: string;
@@ -243,15 +238,6 @@ export interface TableRecord {
     values: RecordValue[][];
     token: TokenPosition;
 }
-export interface MetadataElement {
-    target: {
-        kind: string;
-        name: string[];
-    };
-    values: CustomMetadata;
-    valueTokens: Record<string, TokenPosition>;
-    token: TokenPosition;
-}
 export type Project = Record<string, never> | {
     name: string | null;
     tables: Table[];
@@ -266,4 +252,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;

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

@@ -1,5 +1,5 @@
 import { default as Compiler } from '../../../compiler';
-import { AttributeNode, ElementDeclarationNode, MetadataDeclarationNode, SyntaxNode } from '../nodes';
+import { AttributeNode, ElementDeclarationNode, SyntaxNode } from '../nodes';
 import { ColumnSymbol, NodeSymbol, TablePartialSymbol, TableSymbol } from '../symbol';
 import { Internable } from '../internable';
 export declare enum MetadataKind {
@@ -8,8 +8,7 @@ export declare enum MetadataKind {
     TableChecks = "table checks",
     Indexes = "indexes",
     Records = "records",
-    Project = "project",
-    MetadataElement = "metadata element"
+    Project = "project"
 }
 declare const __nodeMetadataBrand: unique symbol;
 export type NodeMetadataId = number & {
@@ -27,7 +26,6 @@ export declare abstract class NodeMetadata implements Internable<InternedNodeMet
     constructor(declaration: SyntaxNode);
     intern(): InternedNodeMetadata;
     abstract owners(compiler: Compiler): NodeSymbol[];
-    reachableOwners(compiler: Compiler, targets: NodeSymbol[]): NodeSymbol[];
 }
 export declare class RefMetadata extends NodeMetadata {
     declaration: ElementDeclarationNode | AttributeNode;
@@ -75,13 +73,6 @@ export declare class RecordsMetadata extends NodeMetadata {
     table(compiler: Compiler): TableSymbol | undefined;
     owners(compiler: Compiler): NodeSymbol[];
 }
-export declare class MetadataElementMetadata extends NodeMetadata {
-    declaration: MetadataDeclarationNode;
-    readonly kind = MetadataKind.MetadataElement;
-    constructor(declaration: MetadataDeclarationNode);
-    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,7 +24,6 @@ export declare enum SymbolKind {
     DiagramViewTableGroup = "DiagramView tablegroup",
     DiagramViewNote = "DiagramView note",
     DiagramViewSchema = "DiagramView schema",
-    Metadata = "Metadata",
     Program = "Program"
 }
 export declare const ImportKind: {
@@ -34,17 +33,8 @@ export declare const ImportKind: {
     TablePartial: SymbolKind;
     Note: SymbolKind;
     Schema: SymbolKind;
-    Metadata: SymbolKind;
 };
 export type ImportKind = (typeof ImportKind)[keyof typeof ImportKind];
-export declare enum MetadataTargetKind {
-    Table = "table",
-    Schema = "schema",
-    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;

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

@@ -8,7 +8,7 @@ export declare function extractElementName(nameNode: SyntaxNode): {
     schemaName: string[];
     name: string;
 };
-export declare function extractColor(node?: SyntaxNode): Color | undefined;
+export declare function extractColor(node: unknown): Color | undefined;
 export declare function processDefaultValue(valueNode?: SyntaxNode): {
     type: 'number' | 'string' | 'boolean' | 'expression';
     value: string | number;

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

@@ -6,9 +6,6 @@ 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

@@ -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';
@@ -25,14 +24,7 @@ export declare function isValidPartialInjection(node?: SyntaxNode): node is Pref
     };
 };
 export declare function isRelationshipOp(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 isValidColor(value?: SyntaxNode): boolean;
 export declare function isValidDefaultValue(value?: SyntaxNode): boolean;
 export type SignedNumberExpression = (PrimaryExpressionNode & {
     expression: LiteralNode & {
@@ -53,11 +45,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 & {
@@ -97,11 +84,7 @@ 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<T extends ElementKind>(node: SyntaxNode | undefined, kind: T): node is ElementDeclarationNode & {
-    type: {
-        value: T;
-    };
-};
+export declare function isElementNode(node: SyntaxNode | undefined, kind: ElementKind): node is ElementDeclarationNode;
 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/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",
   "description": "DBML parser v2",
   "author": "Holistics <dev@holistics.io>",
   "license": "Apache-2.0",
@@ -50,5 +50,5 @@
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "152988f537ab87a9d8320bd41b478495c1acbb0c"
+  "gitHead": "b062d22d3608d8bb2969051721237cf5de28e069"
 }

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

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

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

@@ -1,2 +0,0 @@
-import { GlobalModule } from '../types';
-export declare const metadataModule: GlobalModule;

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

@@ -1,23 +0,0 @@
-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;
-export default class MetadataInterpreter {
-    private declarationNode;
-    private compiler;
-    private filepath;
-    private metadata;
-    constructor(compiler: Compiler, metadata: MetadataElementMetadata, filepath: Filepath);
-    interpret(): Report<MetadataElement>;
-    private interpretTarget;
-    private interpretValues;
-}

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;

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

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

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

@@ -1,2 +0,0 @@
-import { LocalModule } from '../types';
-export declare const metadataModule: LocalModule;

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

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