@dbml/parse 10.0.0-optional-ref.0 → 10.1.0-alpha.0

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

@@ -57,102 +57,134 @@ export declare enum CompileErrorCode {
     INVALID_REF_FIELD = 3039,
     EMPTY_REF = 3040,
     REF_REDEFINED = 3041,
-    INVALID_NOTE_CONTEXT = 3042,
-    INVALID_NOTE = 3043,
-    NOTE_REDEFINED = 3044,
-    NOTE_CONTENT_REDEFINED = 3045,
-    EMPTY_NOTE = 3046,
-    UNKNOWN_NOTE_SETTING = 3047,
-    DUPLICATE_NOTE_SETTING = 3048,
-    INVALID_NOTE_SETTING_VALUE = 3049,
-    INVALID_INDEXES_CONTEXT = 3050,
-    INVALID_INDEXES_FIELD = 3051,
-    INVALID_INDEX = 3052,
-    UNKNOWN_INDEX_SETTING = 3053,
-    DUPLICATE_INDEX_SETTING = 3054,
-    UNEXPECTED_INDEX_SETTING_VALUE = 3055,
-    INVALID_INDEX_SETTING_VALUE = 3056,
-    INVALID_PROJECT_CONTEXT = 3057,
-    PROJECT_REDEFINED = 3058,
-    INVALID_PROJECT_FIELD = 3059,
-    INVALID_CUSTOM_CONTEXT = 3060,
-    INVALID_CUSTOM_ELEMENT_VALUE = 3061,
-    INVALID_ELEMENT_IN_SIMPLE_BODY = 3062,
-    INVALID_TABLE_PARTIAL_CONTEXT = 3063,
-    INVALID_TABLE_PARTIAL_ELEMENT_NAME = 3064,
-    INVALID_TABLE_PARTIAL_SETTING_VALUE = 3065,
-    DUPLICATE_TABLE_PARTIAL_ELEMENT_NAME = 3066,
-    DUPLICATE_TABLE_PARTIAL_SETTING = 3067,
-    INVALID_TABLE_PARTIAL_INJECTION = 3068,
-    INVALID_TABLE_PARTIAL_INJECTION_OP = 3069,
-    INVALID_TABLE_PARTIAL_INJECTION_NAME = 3070,
-    DUPLICATE_TABLE_PARTIAL_INJECTION_NAME = 3071,
-    UNKNOWN_TABLE_PARTIAL_SETTING = 3072,
-    INVALID_TABLE_SETTING_VALUE = 3073,
-    INVALID_CHECKS_CONTEXT = 3074,
-    INVALID_CHECKS_FIELD = 3075,
-    INVALID_CHECK = 3076,
-    UNKNOWN_CHECK_SETTING = 3077,
-    DUPLICATE_CHECK_SETTING = 3078,
-    INVALID_CHECK_SETTING_VALUE = 3079,
-    INVALID_RECORDS_CONTEXT = 3080,
-    INVALID_RECORDS_NAME = 3081,
-    INVALID_RECORDS_FIELD = 3082,
-    DUPLICATE_COLUMN_REFERENCES_IN_RECORDS = 3083,
-    DUPLICATE_RECORDS_FOR_TABLE = 3084,
-    INVALID_USE_CONTEXT = 3085,
-    INVALID_USE_SPECIFIER_KIND = 3086,
-    INVALID_USE_SPECIFIER_NAME = 3087,
-    INVALID_DIAGRAMVIEW_CONTEXT = 3088,
-    DUPLICATE_DIAGRAMVIEW_NAME = 3089,
-    INVALID_DIAGRAMVIEW_FIELD = 3090,
-    DUPLICATE_DIAGRAMVIEW_FIELD = 3091,
+    INVALID_DEP_CONTEXT = 3042,
+    INVALID_DEP_FIELD = 3043,
+    INVALID_NOTE_CONTEXT = 3044,
+    INVALID_NOTE = 3045,
+    NOTE_REDEFINED = 3046,
+    NOTE_CONTENT_REDEFINED = 3047,
+    EMPTY_NOTE = 3048,
+    UNKNOWN_NOTE_SETTING = 3049,
+    DUPLICATE_NOTE_SETTING = 3050,
+    INVALID_NOTE_SETTING_VALUE = 3051,
+    INVALID_INDEXES_CONTEXT = 3052,
+    INVALID_INDEXES_FIELD = 3053,
+    INVALID_INDEX = 3054,
+    UNKNOWN_INDEX_SETTING = 3055,
+    DUPLICATE_INDEX_SETTING = 3056,
+    UNEXPECTED_INDEX_SETTING_VALUE = 3057,
+    INVALID_INDEX_SETTING_VALUE = 3058,
+    INVALID_PROJECT_CONTEXT = 3059,
+    PROJECT_REDEFINED = 3060,
+    INVALID_PROJECT_FIELD = 3061,
+    INVALID_CUSTOM_CONTEXT = 3062,
+    INVALID_CUSTOM_ELEMENT_VALUE = 3063,
+    INVALID_ELEMENT_IN_SIMPLE_BODY = 3064,
+    INVALID_TABLE_PARTIAL_CONTEXT = 3065,
+    INVALID_TABLE_PARTIAL_ELEMENT_NAME = 3066,
+    INVALID_TABLE_PARTIAL_SETTING_VALUE = 3067,
+    DUPLICATE_TABLE_PARTIAL_ELEMENT_NAME = 3068,
+    DUPLICATE_TABLE_PARTIAL_SETTING = 3069,
+    INVALID_TABLE_PARTIAL_INJECTION = 3070,
+    INVALID_TABLE_PARTIAL_INJECTION_OP = 3071,
+    INVALID_TABLE_PARTIAL_INJECTION_NAME = 3072,
+    DUPLICATE_TABLE_PARTIAL_INJECTION_NAME = 3073,
+    UNKNOWN_TABLE_PARTIAL_SETTING = 3074,
+    INVALID_TABLE_SETTING_VALUE = 3075,
+    INVALID_CHECKS_CONTEXT = 3076,
+    INVALID_CHECKS_FIELD = 3077,
+    INVALID_CHECK = 3078,
+    UNKNOWN_CHECK_SETTING = 3079,
+    DUPLICATE_CHECK_SETTING = 3080,
+    INVALID_CHECK_SETTING_VALUE = 3081,
+    INVALID_RECORDS_CONTEXT = 3082,
+    INVALID_RECORDS_NAME = 3083,
+    INVALID_RECORDS_FIELD = 3084,
+    DUPLICATE_COLUMN_REFERENCES_IN_RECORDS = 3085,
+    DUPLICATE_RECORDS_FOR_TABLE = 3086,
+    INVALID_USE_CONTEXT = 3087,
+    INVALID_USE_SPECIFIER_KIND = 3088,
+    INVALID_USE_SPECIFIER_NAME = 3089,
+    INVALID_DIAGRAMVIEW_CONTEXT = 3090,
+    DUPLICATE_DIAGRAMVIEW_NAME = 3091,
+    INVALID_DIAGRAMVIEW_FIELD = 3092,
+    DUPLICATE_DIAGRAMVIEW_FIELD = 3093,
     BINDING_ERROR = 4000,
     NONEXISTENT_MODULE = 4001,
     UNSUPPORTED = 5000,
     CIRCULAR_REF = 5001,
     SAME_ENDPOINT = 5002,
-    UNEQUAL_FIELDS_BINARY_REF = 5003,
-    CONFLICTING_SETTING = 5004,
-    TABLE_REAPPEAR_IN_TABLEGROUP = 5005
+    DEP_SELF_LOOP = 5003,
+    DEP_MIXED_DOWNSTREAM_TABLES = 5004,
+    DEP_DUPLICATE_DOWNSTREAM_TABLE = 5005,
+    DEP_MIXED_LEVEL = 5006,
+    UNEQUAL_FIELDS_BINARY_REF = 5007,
+    CONFLICTING_SETTING = 5008,
+    TABLE_REAPPEAR_IN_TABLEGROUP = 5009,
+    INVALID_METADATA_TARGET_KIND = 5010,
+    INVALID_METADATA_FIELD = 5011,
+    DUPLICATE_METADATA_FIELD = 5012
 }
 export interface RelatedLocation {
     nodeOrToken: SyntaxNode | SyntaxToken;
     message: string;
 }
-export declare class CompileError extends Error {
+export interface QuickFix {
+    title: string;
+    shortTitle?: string;
+    filepath: Filepath;
+    edits: TextEdit[];
+    isPreferred?: boolean;
+}
+export declare enum DiagnosticCategory {
+    RefColumnMismatch = "Mismatched optional ref constraints",
+    RecordValueTypeMismatch = "Record type errors",
+    RecordConstraintViolation = "Record constraint violations",
+    Other = "Other"
+}
+export interface CompileDetails {
+    category?: DiagnosticCategory;
+    explanation?: string;
+    quickFixes?: QuickFix[];
+}
+export interface CompileDiagnostic extends Error {
     code: Readonly<CompileErrorCode>;
     diagnostic: Readonly<string>;
+    details?: Readonly<CompileDetails>;
     nodeOrToken: Readonly<SyntaxNode | SyntaxToken>;
     start: Readonly<number>;
     end: Readonly<number>;
-    constructor(code: number, message: string, nodeOrToken: SyntaxNode | SyntaxToken);
+    filepath: Filepath;
+}
+export declare class CompileError extends Error implements CompileDiagnostic {
+    code: Readonly<CompileErrorCode>;
+    diagnostic: Readonly<string>;
+    details?: Readonly<CompileDetails>;
+    nodeOrToken: Readonly<SyntaxNode | SyntaxToken>;
+    start: Readonly<number>;
+    end: Readonly<number>;
+    constructor(code: number, message: string, nodeOrToken: SyntaxNode | SyntaxToken, details?: CompileDetails);
     toWarning(): CompileWarning;
     get filepath(): Filepath;
 }
-export declare class CompileWarning extends Error {
+export declare class CompileWarning extends Error implements CompileDiagnostic {
     code: Readonly<CompileErrorCode>;
     diagnostic: Readonly<string>;
+    details?: Readonly<CompileDetails>;
     nodeOrToken: Readonly<SyntaxNode | SyntaxToken>;
     start: Readonly<number>;
     end: Readonly<number>;
-    constructor(code: number, message: string, nodeOrToken: SyntaxNode | SyntaxToken);
+    constructor(code: number, message: string, nodeOrToken: SyntaxNode | SyntaxToken, details?: CompileDetails);
     get filepath(): Filepath;
 }
-export interface QuickFix {
-    title: string;
-    filepath: Filepath;
-    edits: TextEdit[];
-}
-export declare class CompileInfo extends Error {
+export declare class CompileInfo extends Error implements CompileDiagnostic {
     code: Readonly<CompileErrorCode>;
     diagnostic: Readonly<string>;
+    details?: Readonly<CompileDetails>;
     nodeOrToken: Readonly<SyntaxNode | SyntaxToken>;
     start: Readonly<number>;
     end: Readonly<number>;
-    quickFixes?: QuickFix[];
-    constructor(code: number, message: string, nodeOrToken: SyntaxNode | SyntaxToken, options?: {
-        quickFixes?: QuickFix[];
-    });
+    constructor(code: number, message: string, nodeOrToken: SyntaxNode | SyntaxToken, details?: CompileDetails);
+    get quickFixes(): QuickFix[] | undefined;
     get filepath(): Filepath;
 }

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

@@ -2,6 +2,7 @@ export declare enum ElementKind {
     Table = "table",
     Enum = "enum",
     Ref = "ref",
+    Dep = "dep",
     Note = "note",
     Project = "project",
     Indexes = "indexes",
@@ -13,7 +14,8 @@ export declare enum ElementKind {
     DiagramViewTables = "tables",
     DiagramViewNotes = "notes",
     DiagramViewTableGroups = "tablegroups",
-    DiagramViewSchemas = "schemas"
+    DiagramViewSchemas = "schemas",
+    Metadata = "metadata"
 }
 export declare enum SettingName {
     Color = "color",
@@ -23,6 +25,7 @@ export declare enum SettingName {
     PrimaryKey = "primary key",
     Unique = "unique",
     Ref = "ref",
+    Dep = "dep",
     NotNull = "not null",
     Null = "null",
     Increment = "increment",

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

@@ -110,14 +110,16 @@ export declare class UseSpecifierListNode extends SyntaxNode {
 }
 export declare class ElementDeclarationNode extends SyntaxNode {
     type?: SyntaxToken;
+    targetKind?: SyntaxToken;
     name?: NormalExpressionNode;
     as?: SyntaxToken;
     alias?: NormalExpressionNode;
     attributeList?: ListExpressionNode;
     bodyColon?: SyntaxToken;
     body?: FunctionApplicationNode | BlockExpressionNode;
-    constructor({ type, name, as, alias, attributeList, bodyColon, body, }: {
+    constructor({ type, targetKind, name, as, alias, attributeList, bodyColon, body, }: {
         type?: SyntaxToken;
+        targetKind?: SyntaxToken;
         name?: NormalExpressionNode;
         as?: SyntaxToken;
         alias?: NormalExpressionNode;
@@ -125,8 +127,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/relation.d.ts

@@ -1,17 +1,21 @@
 type BaseRelationshipOp = '>' | '<' | '-' | '<>';
 export type RelationshipOp = `${'?' | ''}${BaseRelationshipOp}${'?' | ''}`;
 export type RelationCardinality = `${number}` | '*' | `${number}..${number | '*'}`;
-export declare function normalizeCardinality(c: RelationCardinality): RelationCardinality;
 export declare function parseCardinality(c: RelationCardinality): {
     min: number;
     max: number | '*';
 };
-export declare const RELATIONSHIP_OPS: ReadonlySet<RelationshipOp>;
 export declare const CARDINALITY_ONE: RelationCardinality;
 export declare const CARDINALITY_MAYBE: RelationCardinality;
 export declare const CARDINALITY_SOME: RelationCardinality;
 export declare const CARDINALITY_MANY: RelationCardinality;
+export declare const RELATIONSHIP_OPS: ReadonlyMap<RelationshipOp, [RelationCardinality, RelationCardinality]>;
 export declare function getMultiplicities(op: string): [RelationCardinality, RelationCardinality] | undefined;
+export declare function isEndpointOneSide(relation: RelationCardinality): boolean;
+export declare function isEndpointManySide(relation: RelationCardinality): boolean;
+export declare function isEndpointOptional(relation: RelationCardinality): boolean;
+export declare function isEndpointRequired(relation: RelationCardinality): boolean;
+export declare function makeRelationshipRequired(op: RelationshipOp): BaseRelationshipOp;
 export declare function getRelationshipOp(left: RelationCardinality, right: RelationCardinality): RelationshipOp;
 export declare function makeCardinalityOptional(rel: RelationCardinality): RelationCardinality;
 export declare function makeCardinalityRequired(rel: RelationCardinality): RelationCardinality;

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

@@ -2,6 +2,7 @@ import { NONE_COLOR } from '../../../constants';
 import { Filepath } from '../filepath';
 import { Position } from '../position';
 import { RelationshipOp, RelationCardinality } from '../relation';
+export type CustomMetadata = Record<string, string>;
 export type Color = `#${string}` | typeof NONE_COLOR;
 export declare enum AliasKind {
     Table = "table"
@@ -59,6 +60,7 @@ export interface Database {
     tables: Table[];
     notes: Note[];
     refs: Ref[];
+    deps: Dep[];
     enums: Enum[];
     tableGroups: TableGroup[];
     aliases: Alias[];
@@ -86,12 +88,14 @@ 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;
@@ -111,6 +115,7 @@ export interface Column {
     type: ColumnType;
     token: TokenPosition;
     inline_refs: InlineRef[];
+    inline_deps: InlineDep[];
     checks: Check[];
     pk?: boolean;
     dbdefault?: {
@@ -124,6 +129,7 @@ export interface Column {
         value: string;
         token: TokenPosition;
     };
+    metadata?: CustomMetadata;
 }
 export interface Index {
     columns: {
@@ -171,6 +177,39 @@ export interface RefEndpoint {
     relation: RelationCardinality;
     token: TokenPosition;
 }
+export interface Dep {
+    schemaName: string | null;
+    name: string | null;
+    edges: DepEdge[];
+    color?: Color;
+    note?: {
+        value: string;
+        token: TokenPosition;
+    };
+    metadata?: Record<string, string | number | boolean | null>;
+    token: TokenPosition;
+}
+export interface DepEdge {
+    upstream: DepEndpoint;
+    downstream: DepEndpoint;
+    token: TokenPosition;
+}
+export interface DepEndpoint {
+    schemaName: string | null;
+    tableName: string;
+    fieldNames: string[];
+    token: TokenPosition;
+}
+export declare const DEP_DOWNSTREAM: "->";
+export declare const DEP_UPSTREAM: "<-";
+export type DepDirection = typeof DEP_DOWNSTREAM | typeof DEP_UPSTREAM;
+export interface InlineDep {
+    schemaName: string | null;
+    tableName: string;
+    fieldNames: string[];
+    direction: DepDirection;
+    token: TokenPosition;
+}
 export interface Enum {
     name: string;
     schemaName: string | null;
@@ -195,6 +234,7 @@ export interface TableGroup {
         value: string;
         token: TokenPosition;
     };
+    metadata?: CustomMetadata;
 }
 export interface TableGroupField {
     name: string;
@@ -238,6 +278,10 @@ export interface TableRecord {
     values: RecordValue[][];
     token: TokenPosition;
 }
+export type MetadataValues = Record<string, {
+    value: string;
+    token: TokenPosition;
+}>;
 export type Project = Record<string, never> | {
     name: string | null;
     tables: Table[];
@@ -252,4 +296,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 | InlineDep | Ref | RefEndpoint | Dep | DepEdge | DepEndpoint | Enum | EnumField | TableGroup | TableGroupField | Alias | TablePartial | TablePartialInjection | TableRecord | RecordValue | MetadataValues;

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

@@ -1,16 +1,18 @@
 import { default as Compiler } from '../../../compiler';
-import { AttributeNode, ElementDeclarationNode, SyntaxNode } from '../nodes';
+import { AttributeNode, ElementDeclarationNode, InfixExpressionNode, SyntaxNode } from '../nodes';
 import { SyntaxToken } from '../tokens';
-import { ColumnSymbol, NodeSymbol, TablePartialSymbol, TableSymbol } from '../symbol';
+import { ColumnSymbol, NodeSymbol, ProgramSymbol, TablePartialSymbol, TableSymbol } from '../symbol';
 import { Internable } from '../internable';
 import { RelationshipOp, RelationCardinality } from '../relation';
 export declare enum MetadataKind {
     Ref = "ref",
+    Dep = "dep",
     PartialRef = "partial ref",
     TableChecks = "table checks",
     Indexes = "indexes",
     Records = "records",
-    Project = "project"
+    Project = "project",
+    MetadataElement = "metadata element"
 }
 declare const __nodeMetadataBrand: unique symbol;
 export type NodeMetadataId = number & {
@@ -28,6 +30,11 @@ export declare abstract class NodeMetadata implements Internable<InternedNodeMet
     constructor(declaration: SyntaxNode);
     intern(): InternedNodeMetadata;
     abstract owners(compiler: Compiler): NodeSymbol[];
+    /** Get programs (source files) that can both
+      * - reach this metadata's declaration file and
+      * - see all the given target symbols in their nested schema.
+      */
+    resolveOwnerPrograms(compiler: Compiler, targets: NodeSymbol[]): ProgramSymbol[];
 }
 export declare class RefMetadata extends NodeMetadata {
     declaration: ElementDeclarationNode | AttributeNode;
@@ -54,6 +61,19 @@ export declare class RefMetadata extends NodeMetadata {
     rightToken(): SyntaxNode;
     owners(compiler: Compiler): NodeSymbol[];
 }
+export declare class DepMetadata extends NodeMetadata {
+    declaration: ElementDeclarationNode | AttributeNode;
+    readonly kind = MetadataKind.Dep;
+    constructor(declaration: ElementDeclarationNode | AttributeNode);
+    container(compiler: Compiler): TableSymbol | undefined;
+    edgeExpressions(): InfixExpressionNode[];
+    upstreamColumns(compiler: Compiler): ColumnSymbol[][];
+    downstreamColumns(compiler: Compiler): ColumnSymbol[][];
+    upstreamTables(compiler: Compiler): (TableSymbol | undefined)[];
+    downstreamTables(compiler: Compiler): (TableSymbol | undefined)[];
+    private hostColumn;
+    owners(compiler: Compiler): NodeSymbol[];
+}
 export declare class PartialRefMetadata extends NodeMetadata {
     readonly kind = MetadataKind.PartialRef;
     constructor(declaration: SyntaxNode);
@@ -65,14 +85,6 @@ export declare class PartialRefMetadata extends NodeMetadata {
     op(_compiler: Compiler): RelationshipOp | undefined;
     opToken(): SyntaxToken | undefined;
     cardinalities(compiler: Compiler): [RelationCardinality, RelationCardinality] | undefined;
-    leftCardinality(compiler: Compiler): {
-        min: number;
-        max: number | '*';
-    } | undefined;
-    rightCardinality(compiler: Compiler): {
-        min: number;
-        max: number | '*';
-    } | undefined;
     leftToken(): SyntaxNode;
     rightToken(): SyntaxNode;
     owners(compiler: Compiler): NodeSymbol[];
@@ -95,6 +107,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: {
@@ -35,6 +36,13 @@ export declare const ImportKind: {
     Schema: SymbolKind;
 };
 export type ImportKind = (typeof ImportKind)[keyof typeof ImportKind];
+/** Allowed target element types for a Metadata element header */
+export declare enum MetadataTargetKind {
+    Table = "Table",
+    Column = "Column",
+    TableGroup = "TableGroup",
+    Note = "Note"
+}
 declare const __nodeSymbolBrand: unique symbol;
 export type NodeSymbolId = number & {
     readonly [__nodeSymbolBrand]: true;
@@ -147,11 +155,12 @@ export declare class ColumnSymbol extends NodeSymbol {
     }, id: NodeSymbolId, filepath: Filepath);
     get canBeImported(): boolean;
     get originalSymbol(): NodeSymbol;
-    qualifiedName(compiler: Compiler): string;
+    qualifiedName(compiler: Compiler): string[];
     pk(compiler: Compiler): boolean;
     isUniqueSet(compiler: Compiler): boolean;
     unique(compiler: Compiler): boolean;
     nullable(compiler: Compiler): boolean;
+    private isInPkIndex;
     isNotNullSet(compiler: Compiler): boolean | undefined;
     isIncrementSet(compiler: Compiler): boolean;
     increment(compiler: Compiler): boolean;

package/dist/src/core/utils/diagnostics_reporter/index.d.ts

@@ -0,0 +1,2 @@
+export { refNullableMismatch, refNotNullMismatch, refUniqueMismatch, refNonUniqueMismatch, } from './ref';
+export { recordsNullNotAllowed, recordsInvalidEnum, recordsInvalidNumeric, recordsInvalidInteger, recordsExceedsPrecision, recordsExceedsScale, recordsInvalidBoolean, recordsInvalidDatetime, recordsInvalidString, recordsStringTooLong, recordsPkNull, recordsPkDuplicate, recordsPkMissing, recordsFkNull, recordsFkNotFound, recordsUniqueDuplicate, } from './records';

package/dist/src/core/utils/diagnostics_reporter/records.d.ts

@@ -0,0 +1,87 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileInfo } from '../../types/errors';
+import { SyntaxNode } from '../../types/nodes';
+import { SyntaxToken } from '../../types/tokens';
+import { ColumnSymbol } from '../../types/symbol';
+import { Filepath } from '../../types/filepath';
+import { TableSymbol } from '../../types/symbol/symbols';
+export declare function recordsNullNotAllowed(node: SyntaxNode | SyntaxToken, options: {
+    colName: string;
+}): CompileInfo;
+export declare function recordsInvalidEnum(node: SyntaxNode | SyntaxToken, options: {
+    colName: string;
+}): CompileInfo;
+export declare function recordsInvalidNumeric(node: SyntaxNode | SyntaxToken, options: {
+    colName: string;
+    typeName: string;
+}): CompileInfo;
+export declare function recordsInvalidInteger(node: SyntaxNode | SyntaxToken, options: {
+    colName: string;
+    value: number;
+}): CompileInfo;
+export declare function recordsExceedsPrecision(node: SyntaxNode | SyntaxToken, options: {
+    colName: string;
+    typeName: string;
+    value: number;
+    precision: number;
+    scale: number;
+    totalDigits: number;
+}): CompileInfo;
+export declare function recordsExceedsScale(node: SyntaxNode | SyntaxToken, options: {
+    colName: string;
+    typeName: string;
+    value: number;
+    precision: number;
+    scale: number;
+    decimalDigits: number;
+}): CompileInfo;
+export declare function recordsInvalidBoolean(node: SyntaxNode | SyntaxToken, options: {
+    colName: string;
+}): CompileInfo;
+export declare function recordsInvalidDatetime(node: SyntaxNode | SyntaxToken, options: {
+    colName: string;
+}): CompileInfo;
+export declare function recordsInvalidString(node: SyntaxNode | SyntaxToken, options: {
+    colName: string;
+}): CompileInfo;
+export declare function recordsStringTooLong(node: SyntaxNode | SyntaxToken, options: {
+    colName: string;
+    typeName: string;
+    typeArg: string;
+    maxLength: number;
+    actualLength: number;
+}): CompileInfo;
+export declare function recordsPkNull(compiler: Compiler, node: SyntaxNode | SyntaxToken, options: {
+    table: TableSymbol;
+    columns: ColumnSymbol[];
+}): CompileInfo;
+export declare function recordsPkDuplicate(compiler: Compiler, node: SyntaxNode | SyntaxToken, options: {
+    table: TableSymbol;
+    columns: ColumnSymbol[];
+    valueStr: string;
+}): CompileInfo;
+export declare function recordsPkMissing(compiler: Compiler, node: SyntaxNode | SyntaxToken, options: {
+    table: TableSymbol;
+    columns: ColumnSymbol[];
+}): CompileInfo;
+export declare function recordsFkNull(compiler: Compiler, node: SyntaxNode | SyntaxToken, options: {
+    leftTable: TableSymbol;
+    leftColumns: ColumnSymbol[];
+    rightTable: TableSymbol;
+    rightColumns: ColumnSymbol[];
+    filepath: Filepath;
+    valueStr: string;
+}): CompileInfo;
+export declare function recordsFkNotFound(compiler: Compiler, node: SyntaxNode | SyntaxToken, options: {
+    leftTable: TableSymbol;
+    leftColumns: ColumnSymbol[];
+    rightTable: TableSymbol;
+    rightColumns: ColumnSymbol[];
+    filepath: Filepath;
+    valueStr: string;
+}): CompileInfo;
+export declare function recordsUniqueDuplicate(compiler: Compiler, node: SyntaxNode | SyntaxToken, options: {
+    table: TableSymbol;
+    columns: ColumnSymbol[];
+    valueStr: string;
+}): CompileInfo;

package/dist/src/core/utils/diagnostics_reporter/ref.d.ts

@@ -0,0 +1,30 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileInfo, QuickFix } from '../../types/errors';
+import { SyntaxNode } from '../../types/nodes';
+import { SyntaxToken } from '../../types/tokens';
+import { ColumnSymbol } from '../../types/symbol';
+import { RelationshipOp } from '../../types/relation';
+export declare function refNullableMismatch(compiler: Compiler, node: SyntaxNode | SyntaxToken, options: {
+    relOp: RelationshipOp;
+    columns: ColumnSymbol[];
+    refNode: SyntaxNode;
+    quickFixes?: QuickFix[];
+}): CompileInfo;
+export declare function refNotNullMismatch(compiler: Compiler, node: SyntaxNode | SyntaxToken, options: {
+    relOp: RelationshipOp;
+    columns: ColumnSymbol[];
+    refNode: SyntaxNode;
+    quickFixes?: QuickFix[];
+}): CompileInfo;
+export declare function refUniqueMismatch(compiler: Compiler, node: SyntaxNode | SyntaxToken, options: {
+    relOp: RelationshipOp;
+    columns: ColumnSymbol[];
+    refNode: SyntaxNode;
+    quickFixes?: QuickFix[];
+}): CompileInfo;
+export declare function refNonUniqueMismatch(compiler: Compiler, node: SyntaxNode | SyntaxToken, options: {
+    relOp: RelationshipOp;
+    columns: ColumnSymbol[];
+    refNode: SyntaxNode;
+    quickFixes?: QuickFix[];
+}): CompileInfo;

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

@@ -1,4 +1,4 @@
-import { ElementDeclarationNode, FunctionApplicationNode, FunctionExpressionNode, IdentifierStreamNode, PrimaryExpressionNode, SyntaxNode, TupleExpressionNode, VariableNode } from '../types/nodes';
+import { AttributeNode, ElementDeclarationNode, FunctionApplicationNode, FunctionExpressionNode, IdentifierStreamNode, PrimaryExpressionNode, SyntaxNode, TupleExpressionNode, VariableNode } from '../types/nodes';
 import { SyntaxToken } from '../types/tokens';
 export declare function extractVariableNode(value?: unknown): SyntaxToken | undefined;
 export declare function extractStringFromIdentifierStream(stream?: IdentifierStreamNode): string | undefined;
@@ -35,3 +35,4 @@ export declare function extractVariableFromExpression(node?: SyntaxNode): string
 export declare function extractVarNameFromPrimaryVariable(node?: PrimaryExpressionNode & {
     expression: VariableNode;
 }): string | undefined;
+export declare function extractSettingName(attr: AttributeNode): string | undefined;