@dbml/parse 8.3.0 → 8.3.1-custom-metadata.0

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>;
+        element: (filepath: Filepath, offset: number) => Readonly<import('../core/types/nodes').ElementDeclarationNode | import('../core/types/nodes').ProgramNode | import('../core/types/nodes').MetadataDeclarationNode>;
         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, ProgramNode } from '../../../core/types/nodes';
+import { ElementDeclarationNode, MetadataDeclarationNode, ProgramNode } from '../../../core/types/nodes';
 import { default as Compiler } from '../../index';
-export declare function containerElement(this: Compiler, filepath: Filepath, offset: number): Readonly<ElementDeclarationNode | ProgramNode>;
+export declare function containerElement(this: Compiler, filepath: Filepath, offset: number): Readonly<ElementDeclarationNode | MetadataDeclarationNode | ProgramNode>;

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

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

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

@@ -0,0 +1,11 @@
+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

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

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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,4 @@
+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/global_modules/utils.d.ts

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

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

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

@@ -0,0 +1,14 @@
+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;
+}

package/dist/src/core/parser/parser.d.ts

@@ -32,6 +32,7 @@ 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,7 +113,13 @@ export declare enum CompileErrorCode {
     SAME_ENDPOINT = 5002,
     UNEQUAL_FIELDS_BINARY_REF = 5003,
     CONFLICTING_SETTING = 5004,
-    TABLE_REAPPEAR_IN_TABLEGROUP = 5005
+    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
 }
 export declare class CompileError extends Error {
     code: Readonly<CompileErrorCode>;

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, SymbolKind } from './symbol';
+import { ImportKind, MetadataTargetKind, SymbolKind } from './symbol';
 import { Position } from './position';
 import { SyntaxToken } from './tokens';
 export type SyntaxNodeId = number;
@@ -36,6 +36,7 @@ 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>",
@@ -60,16 +61,17 @@ export declare enum SyntaxNodeKind {
     WILDCARD = "<wildcard>"
 }
 export declare class ProgramNode extends SyntaxNode {
-    body: (UseDeclarationNode | ElementDeclarationNode)[];
+    body: (UseDeclarationNode | ElementDeclarationNode | MetadataDeclarationNode)[];
     eof?: SyntaxToken;
     source: string;
     constructor({ body, eof, source, }: {
-        body?: (UseDeclarationNode | ElementDeclarationNode)[];
+        body?: (UseDeclarationNode | ElementDeclarationNode | MetadataDeclarationNode)[];
         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;
@@ -86,11 +88,13 @@ export declare class UseDeclarationNode extends SyntaxNode {
 }
 export declare class UseSpecifierNode extends SyntaxNode {
     importKind?: SyntaxToken;
+    subKind?: SyntaxToken;
     name?: NormalExpressionNode;
     asKeyword?: SyntaxToken;
     alias?: NormalExpressionNode;
-    constructor({ importKind, name, asKeyword, alias, }: {
+    constructor({ importKind, subKind, name, asKeyword, alias, }: {
         importKind?: SyntaxToken;
+        subKind?: SyntaxToken;
         name?: NormalExpressionNode;
         asKeyword?: SyntaxToken;
         alias?: NormalExpressionNode;
@@ -108,6 +112,21 @@ 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;
@@ -125,8 +144,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/schemaJson.d.ts

@@ -66,6 +66,7 @@ export interface Database {
     records: TableRecord[];
     externals: DatabaseExternals;
     diagramViews: DiagramView[];
+    metadataElements: MetadataElement[];
     token?: TokenPosition;
 }
 export interface MasterDatabase {
@@ -238,6 +239,16 @@ 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[];
@@ -252,4 +263,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 | Ref | RefEndpoint | Enum | EnumField | TableGroup | TableGroupField | Alias | TablePartial | TablePartialInjection | TableRecord | RecordValue | MetadataElement;

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

@@ -1,5 +1,5 @@
 import { default as Compiler } from '../../../compiler';
-import { AttributeNode, ElementDeclarationNode, SyntaxNode } from '../nodes';
+import { AttributeNode, ElementDeclarationNode, MetadataDeclarationNode, SyntaxNode } from '../nodes';
 import { ColumnSymbol, NodeSymbol, TablePartialSymbol, TableSymbol } from '../symbol';
 import { Internable } from '../internable';
 export declare enum MetadataKind {
@@ -8,7 +8,8 @@ export declare enum MetadataKind {
     TableChecks = "table checks",
     Indexes = "indexes",
     Records = "records",
-    Project = "project"
+    Project = "project",
+    MetadataElement = "metadata element"
 }
 declare const __nodeMetadataBrand: unique symbol;
 export type NodeMetadataId = number & {
@@ -26,6 +27,7 @@ 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;
@@ -73,6 +75,13 @@ 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,6 +24,7 @@ export declare enum SymbolKind {
     DiagramViewTableGroup = "DiagramView tablegroup",
     DiagramViewNote = "DiagramView note",
     DiagramViewSchema = "DiagramView schema",
+    Metadata = "Metadata",
     Program = "Program"
 }
 export declare const ImportKind: {
@@ -33,8 +34,17 @@ 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, SyntaxNode } from '../types/nodes';
+import { ElementDeclarationNode, MetadataDeclarationNode, 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): boolean;
+export declare function isOffsetWithinElementHeader(offset: number, element: ElementDeclarationNode | MetadataDeclarationNode): boolean;

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

@@ -84,7 +84,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/package.json

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