@dbml/parse 8.3.0 → 8.4.0-metadata.0

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 { MetadataElementNode } from '../../types/nodes';
+export default class MetadataBinder {
+    private compiler;
+    private declarationNode;
+    constructor(compiler: Compiler, declarationNode: MetadataElementNode);
+    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,15 @@
+import { default as Compiler } from '../../../compiler';
+import { Filepath } from '../../types';
+import { MetadataElementMetadata } from '../../types/symbol/metadata';
+import { default as Report } from '../../types/report';
+import { MetadataElement } from '../../types/schemaJson';
+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 { ElementDeclarationNode } from '../../types/nodes';
+import { NodeSymbol } from '../../types/symbol';
+export declare function resolveMetadataTarget(compiler: Compiler, metadataNode: ElementDeclarationNode): 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,28 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileError } from '../../types/errors';
+import { ElementDeclarationNode } from '../../types/nodes';
+import { ElementKind, MetadataTargetKind } from '../../types';
+import { SyntaxToken } from '../../types/tokens';
+export declare function isValidMetadataSubKind(metadataNode: ElementDeclarationNode): metadataNode is ElementDeclarationNode & {
+    subKind: SyntaxToken & {
+        value: MetadataTargetKind;
+    };
+};
+export default class MetadataValidator {
+    private declarationNode;
+    private compiler;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode & {
+        type: {
+            value: ElementKind.Metadata;
+        };
+    });
+    validate(): CompileError[];
+    private validateContext;
+    private validateSubKind;
+    private validateName;
+    private validateAlias;
+    private validateSettingList;
+    private validateBody;
+    private validateFields;
+    private validateSubElements;
+}

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

@@ -113,7 +113,12 @@ 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
 }
 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

@@ -86,11 +86,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;
@@ -110,14 +112,16 @@ export declare class UseSpecifierListNode extends SyntaxNode {
 }
 export declare class ElementDeclarationNode extends SyntaxNode {
     type?: SyntaxToken;
+    subKind?: SyntaxToken;
     name?: NormalExpressionNode;
     as?: SyntaxToken;
     alias?: NormalExpressionNode;
     attributeList?: ListExpressionNode;
     bodyColon?: SyntaxToken;
     body?: FunctionApplicationNode | BlockExpressionNode;
-    constructor({ type, name, as, alias, attributeList, bodyColon, body, }: {
+    constructor({ type, subKind, name, as, alias, attributeList, bodyColon, body, }: {
         type?: SyntaxToken;
+        subKind?: SyntaxToken;
         name?: NormalExpressionNode;
         as?: SyntaxToken;
         alias?: NormalExpressionNode;
@@ -125,9 +129,23 @@ 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 type MetadataElementNode = ElementDeclarationNode & {
+    type: {
+        value: ElementKind.Metadata;
+    };
+};
 export declare class IdentifierStreamNode extends SyntaxNode {
     identifiers: SyntaxToken[];
     constructor({ identifiers, }: {

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

@@ -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: 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: {
@@ -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/validate.d.ts

@@ -2,7 +2,7 @@ import { AttributeNode, BlockExpressionNode, ElementDeclarationNode, FunctionApp
 import { default as Report } from '../types/report';
 import { SyntaxToken, SyntaxTokenKind } from '../types/tokens';
 import { ElementKind, SettingName } from '../types/keywords';
-import { ImportKind } from '../types/symbol';
+import { ImportKind, MetadataTargetKind } from '../types/symbol';
 export declare function isValidName(nameNode: SyntaxNode): boolean;
 export declare function isValidAlias(aliasNode: SyntaxNode): aliasNode is PrimaryExpressionNode & {
     expression: VariableNode;
@@ -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;
@@ -101,4 +105,5 @@ export declare function isValidIndexName(value?: SyntaxNode): value is (PrimaryE
 }) | FunctionExpressionNode;
 export declare function getRightmostVariable(node: SyntaxNode): SyntaxNode | undefined;
 export declare function isTerminalAccessFragment(node: SyntaxNode): boolean;
+export declare function getElementSubKind(elementKind: ElementKind | undefined, subKindToken?: SyntaxToken): MetadataTargetKind | undefined;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@dbml/parse",
-  "version": "8.3.0",
+  "version": "8.4.0-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": "732826ecba8655dfd36d8adcb89f81b597e85fd2"
 }