@dbml/parse 8.3.1-custom-metadata.0 → 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/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,13 +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,
-    DUPLICATE_METADATA_KEY_ACROSS_BLOCKS = 5011
+    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

@@ -66,7 +66,6 @@ export interface Database {
     records: TableRecord[];
     externals: DatabaseExternals;
     diagramViews: DiagramView[];
-    metadataElements: MetadataElement[];
     token?: TokenPosition;
 }
 export interface MasterDatabase {
@@ -239,16 +238,6 @@ export interface TableRecord {
     values: RecordValue[][];
     token: TokenPosition;
 }
-export interface MetadataElement {
-    target: {
-        kind: string;
-        name: string[];
-    };
-    values: {
-        [key: string]: unknown;
-    };
-    token: TokenPosition;
-}
 export type Project = Record<string, never> | {
     name: string | null;
     tables: Table[];
@@ -263,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/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

@@ -84,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.0",
+  "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": "cca14935200249a97ec9575cbbe16f5d491c4fc4"
+  "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,17 +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, MetadataElement } from '../../types/schemaJson';
-export declare function extractValue(node?: SyntaxNode): string | number | boolean | Color | undefined;
-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/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;
-}