@dbml/parse 7.1.2 → 8.0.0-alpha.4

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

@@ -1,8 +1,8 @@
-import { ElementKind } from '../analyzer/types';
-import { Position } from '.';
 import { Filepath } from './filepath';
 import { Internable } from './internable';
-import { NodeSymbol } from './symbol/symbols';
+import { ElementKind } from './keywords';
+import { ImportKind, SymbolKind } from './symbol';
+import { Position } from './position';
 import { SyntaxToken } from './tokens';
 export type SyntaxNodeId = number;
 export type InternedSyntaxNode = string;
@@ -22,19 +22,25 @@ export declare class SyntaxNode implements Internable<InternedSyntaxNode> {
     end: Readonly<number>;
     fullEnd: Readonly<number>;
     parentNode?: SyntaxNode;
-    symbol?: NodeSymbol;
-    referee?: NodeSymbol;
     constructor(id: SyntaxNodeId, kind: SyntaxNodeKind, filepath: Filepath, args: Readonly<SyntaxToken | SyntaxNode | undefined>[]);
     intern(): InternedSyntaxNode;
+    get parent(): ElementDeclarationNode | ProgramNode | undefined;
     parentOfKind<T extends SyntaxNode>(cls: (new (...args: any[]) => T)): T | undefined;
     strictlyContains(otherNode: SyntaxNode): boolean;
+    strictlyContains(otherToken: SyntaxToken): boolean;
+    strictlyContains(offset: number): boolean;
     containsEq(otherNode: SyntaxNode): boolean;
+    containsEq(otherToken: SyntaxToken): boolean;
+    containsEq(offset: number): boolean;
 }
 export declare enum SyntaxNodeKind {
     PROGRAM = "<program>",
     ELEMENT_DECLARATION = "<element-declaration>",
+    USE_DECLARATION = "<use-declaration>",
+    USE_SPECIFIER = "<use-specifier>",
+    USE_SPECIFIER_LIST = "<use-specifier-list>",
     ATTRIBUTE = "<attribute>",
-    IDENTIFIER_STREAM = "<identifer-stream>",
+    IDENTIFIER_STREAM = "<identifier-stream>",
     LITERAL = "<literal>",
     VARIABLE = "<variable>",
     PREFIX_EXPRESSION = "<prefix-expression>",
@@ -49,19 +55,58 @@ export declare enum SyntaxNodeKind {
     PRIMARY_EXPRESSION = "<primary-expression>",
     GROUP_EXPRESSION = "<group-expression>",
     COMMA_EXPRESSION = "<comma-expression>",
-    WILDCARD = "<wildcard>",
     EMPTY = "<dummy>",
-    ARRAY = "<array>"
+    ARRAY = "<array>",
+    WILDCARD = "<wildcard>"
 }
 export declare class ProgramNode extends SyntaxNode {
-    body: ElementDeclarationNode[];
+    body: (UseDeclarationNode | ElementDeclarationNode)[];
     eof?: SyntaxToken;
     source: string;
     constructor({ body, eof, source, }: {
-        body?: ElementDeclarationNode[];
+        body?: (UseDeclarationNode | ElementDeclarationNode)[];
         eof?: SyntaxToken;
         source: string;
     }, id: SyntaxNodeId, filepath: Filepath);
+    get declarations(): ElementDeclarationNode[];
+    get uses(): UseDeclarationNode[];
+}
+export declare class UseDeclarationNode extends SyntaxNode {
+    useKeyword?: SyntaxToken;
+    specifiers?: UseSpecifierListNode | WildcardNode;
+    fromKeyword?: SyntaxToken;
+    importPath?: SyntaxToken;
+    constructor({ useKeyword, specifiers, fromKeyword, importPath, }: {
+        useKeyword?: SyntaxToken;
+        specifiers?: UseSpecifierListNode | WildcardNode;
+        fromKeyword?: SyntaxToken;
+        importPath?: SyntaxToken;
+    }, id: SyntaxNodeId, filepath: Filepath);
+    get isReuse(): boolean;
+}
+export declare class UseSpecifierNode extends SyntaxNode {
+    importKind?: SyntaxToken;
+    name?: NormalExpressionNode;
+    asKeyword?: SyntaxToken;
+    alias?: NormalExpressionNode;
+    constructor({ importKind, name, asKeyword, alias, }: {
+        importKind?: SyntaxToken;
+        name?: NormalExpressionNode;
+        asKeyword?: SyntaxToken;
+        alias?: NormalExpressionNode;
+    }, id: SyntaxNodeId, filepath: Filepath);
+    isKind(...importKinds: ImportKind[]): boolean;
+    getSymbolKind(): SymbolKind | undefined;
+}
+export declare class UseSpecifierListNode extends SyntaxNode {
+    openBrace?: SyntaxToken;
+    specifiers: UseSpecifierNode[];
+    closeBrace?: SyntaxToken;
+    constructor({ openBrace, specifiers, closeBrace, }: {
+        openBrace?: SyntaxToken;
+        specifiers?: UseSpecifierNode[];
+        closeBrace?: SyntaxToken;
+    }, id: SyntaxNodeId, filepath: Filepath);
 }
 export declare class ElementDeclarationNode extends SyntaxNode {
     type?: SyntaxToken;
@@ -70,7 +115,6 @@ export declare class ElementDeclarationNode extends SyntaxNode {
     alias?: NormalExpressionNode;
     attributeList?: ListExpressionNode;
     bodyColon?: SyntaxToken;
-    parent?: ElementDeclarationNode | ProgramNode;
     body?: FunctionApplicationNode | BlockExpressionNode;
     constructor({ type, name, as, alias, attributeList, bodyColon, body, }: {
         type?: SyntaxToken;
@@ -82,21 +126,22 @@ export declare class ElementDeclarationNode extends SyntaxNode {
         body?: BlockExpressionNode | FunctionApplicationNode;
     }, id: SyntaxNodeId, filepath: Filepath);
     isKind(...kinds: ElementKind[]): boolean;
+    getElementKind(): ElementKind | undefined;
 }
-export declare class IdentiferStreamNode extends SyntaxNode {
+export declare class IdentifierStreamNode extends SyntaxNode {
     identifiers: SyntaxToken[];
     constructor({ identifiers, }: {
         identifiers?: SyntaxToken[];
     }, id: SyntaxNodeId, filepath: Filepath);
 }
 export declare class AttributeNode extends SyntaxNode {
-    name?: IdentiferStreamNode | PrimaryExpressionNode;
+    name?: IdentifierStreamNode | PrimaryExpressionNode;
     colon?: SyntaxToken;
-    value?: NormalExpressionNode | IdentiferStreamNode;
+    value?: NormalExpressionNode | IdentifierStreamNode;
     constructor({ name, colon, value, }: {
-        name?: IdentiferStreamNode | PrimaryExpressionNode;
+        name?: IdentifierStreamNode | PrimaryExpressionNode;
         colon?: SyntaxToken;
-        value?: NormalExpressionNode | IdentiferStreamNode;
+        value?: NormalExpressionNode | IdentifierStreamNode;
     }, id: SyntaxNodeId, filepath: Filepath);
 }
 export type NormalExpressionNode = PrefixExpressionNode | InfixExpressionNode | PostfixExpressionNode | BlockExpressionNode | ListExpressionNode | TupleExpressionNode | CommaExpressionNode | CallExpressionNode | PrimaryExpressionNode | FunctionExpressionNode | EmptyNode | ArrayNode;

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

@@ -7,12 +7,12 @@ export default class Report<T> {
     constructor(value: T, errors?: CompileError[], warnings?: CompileWarning[]);
     filter<S extends symbol>(filteredValue: S): Report<undefined | Exclude<T, S>>;
     hasValue<S>(value: S): this is Report<S>;
-    getFiltered<S extends symbol>(filteredValue: S): Exclude<T, typeof filteredValue> | undefined;
+    getFiltered<S extends symbol | undefined | null>(...filteredValues: S[]): Exclude<T, S> | undefined;
     getValue(): T;
     getErrors(): CompileError[];
     getWarnings(): CompileWarning[];
-    chainFiltered<S extends symbol, U>(filteredValue: S, fn: (_: Exclude<T, S>) => Report<U>): Report<U | undefined>;
+    chainFiltered<S extends symbol | undefined | null, U>(fn: (_: Exclude<T, S>) => Report<U>, ...filteredValues: S[]): Report<U | undefined>;
     chain<U>(fn: (_: T) => Report<U>): Report<U>;
-    mapFiltered<S extends symbol, U>(filteredValue: S, fn: (_: T) => U): Report<U | undefined>;
+    mapFiltered<S extends symbol | undefined | null, U>(fn: (_: Exclude<T, S>) => U, ...filteredValues: S[]): Report<U | undefined>;
     map<U>(fn: (_: T) => U): Report<U>;
 }

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

@@ -1,5 +1,8 @@
 import { Filepath } from './filepath';
 import { Position } from './position';
+export declare enum AliasKind {
+    Table = "table"
+}
 export interface TokenPosition {
     start: Position;
     end: Position;
@@ -8,11 +11,19 @@ export interface TokenPosition {
 export interface ElementRef {
     name: string;
     schemaName: string | null;
+    filepath: Filepath;
     visibleNames: {
         schemaName: string | null;
         name: string;
     }[];
 }
+export interface DatabaseExternals {
+    tables: ElementRef[];
+    enums: ElementRef[];
+    tableGroups: ElementRef[];
+    tablePartials: ElementRef[];
+    notes: ElementRef[];
+}
 /**
  * FilterConfig is a tri-state filter:
  * - [] (empty array) = show all
@@ -51,12 +62,12 @@ export interface Database {
     project?: Project;
     tablePartials: TablePartial[];
     records: TableRecord[];
+    externals: DatabaseExternals;
     diagramViews: DiagramView[];
     token?: TokenPosition;
 }
 export interface MasterDatabase {
     files: Record<string, Database>;
-    items: Database;
 }
 export interface Table {
     name: string;
@@ -186,13 +197,10 @@ export interface TableGroupField {
     name: string;
     schemaName: string | null;
 }
-export type AliasKind = 'table' | 'enum' | 'tablegroup' | 'tablepartial' | 'note';
 export interface Alias {
     name: string;
     kind: AliasKind;
     value: {
-        elementName: string;
-        /** @deprecated Use elementName instead */
         tableName: string;
         schemaName: string | null;
     };
@@ -218,9 +226,10 @@ export type RecordValueType = 'string' | 'bool' | 'integer' | 'real' | 'date' |
 export interface RecordValue {
     value: any;
     type: RecordValueType;
+    token: TokenPosition;
 }
 export interface TableRecord {
-    schemaName: string | undefined;
+    schemaName: string | null;
     tableName: string;
     columns: string[];
     values: RecordValue[][];

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

@@ -1,8 +1,9 @@
+import { Filepath } from '../filepath';
 import { NodeSymbol, NodeSymbolId, NodeSymbolIdGenerator } from '.';
 export default class SymbolFactory {
     private generator;
     constructor(generator: NodeSymbolIdGenerator);
     create<T extends NodeSymbol, A>(Type: {
-        new (args: A, id: NodeSymbolId): T;
-    }, args: A): T;
+        new (args: A, id: NodeSymbolId, filepath: Filepath): T;
+    }, args: A, filepath: Filepath): T;
 }

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

@@ -1,5 +1,4 @@
+export * from './factory';
 export * from './symbols';
-export * from './symbolIndex';
-export * from './symbolTable';
-export * from './utils';
+export * from './metadata';
 export { default as SymbolFactory, } from './factory';

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

@@ -0,0 +1,80 @@
+import { default as Compiler } from '../../../compiler';
+import { AttributeNode, ElementDeclarationNode, SyntaxNode } from '../nodes';
+import { ColumnSymbol, NodeSymbol, TablePartialSymbol, TableSymbol } from '../symbol';
+import { Internable } from '../internable';
+export declare enum MetadataKind {
+    Ref = "ref",
+    PartialRef = "partial ref",
+    TableChecks = "table checks",
+    Indexes = "indexes",
+    Records = "records",
+    Project = "project"
+}
+declare const __nodeMetadataBrand: unique symbol;
+export type NodeMetadataId = number & {
+    readonly [__nodeMetadataBrand]: true;
+};
+declare const __internedNodeMetadataBrand: unique symbol;
+export type InternedNodeMetadata = string & {
+    readonly [__internedNodeMetadataBrand]: true;
+};
+export declare abstract class NodeMetadata implements Internable<InternedNodeMetadata> {
+    private static id;
+    abstract readonly kind: MetadataKind;
+    declaration: SyntaxNode;
+    id: NodeMetadataId;
+    constructor(declaration: SyntaxNode);
+    intern(): InternedNodeMetadata;
+    abstract owners(compiler: Compiler): NodeSymbol[];
+}
+export declare class RefMetadata extends NodeMetadata {
+    declaration: ElementDeclarationNode | AttributeNode;
+    readonly kind = MetadataKind.Ref;
+    constructor(declaration: ElementDeclarationNode | AttributeNode);
+    container(compiler: Compiler): TableSymbol | undefined;
+    leftColumns(compiler: Compiler): ColumnSymbol[];
+    rightColumns(compiler: Compiler): ColumnSymbol[];
+    leftTable(compiler: Compiler): TableSymbol | undefined;
+    rightTable(compiler: Compiler): TableSymbol | undefined;
+    op(_compiler: Compiler): '>' | '<' | '-' | '<>' | undefined;
+    leftToken(): SyntaxNode;
+    rightToken(): SyntaxNode;
+    owners(compiler: Compiler): NodeSymbol[];
+}
+export declare class PartialRefMetadata extends NodeMetadata {
+    readonly kind = MetadataKind.PartialRef;
+    constructor(declaration: SyntaxNode);
+    container(compiler: Compiler): TablePartialSymbol | undefined;
+    leftColumns(compiler: Compiler): ColumnSymbol[];
+    rightColumns(compiler: Compiler): ColumnSymbol[];
+    leftTablePartial(compiler: Compiler): TablePartialSymbol | undefined;
+    rightTable(compiler: Compiler): TableSymbol | TablePartialSymbol | undefined;
+    op(_compiler: Compiler): '>' | '<' | '-' | '<>' | undefined;
+    leftToken(): SyntaxNode;
+    rightToken(): SyntaxNode;
+    owners(compiler: Compiler): NodeSymbol[];
+}
+export declare class TableChecksMetadata extends NodeMetadata {
+    readonly kind = MetadataKind.TableChecks;
+    private ownerTable;
+    constructor(declaration: ElementDeclarationNode);
+    owners(compiler: Compiler): NodeSymbol[];
+}
+export declare class IndexesMetadata extends NodeMetadata {
+    readonly kind = MetadataKind.Indexes;
+    private ownerTable;
+    constructor(declaration: SyntaxNode);
+    owners(compiler: Compiler): NodeSymbol[];
+}
+export declare class RecordsMetadata extends NodeMetadata {
+    readonly kind = MetadataKind.Records;
+    constructor(declaration: SyntaxNode);
+    table(compiler: Compiler): TableSymbol | undefined;
+    owners(compiler: Compiler): NodeSymbol[];
+}
+export declare class ProjectMetadata extends NodeMetadata {
+    readonly kind = MetadataKind.Project;
+    constructor(declaration: SyntaxNode);
+    owners(compiler: Compiler): NodeSymbol[];
+}
+export {};