@dbml/parse 9.0.0-optional-ref.0 → 9.0.0-optional-ref.3

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

@@ -1,7 +1,7 @@
 import { Filepath } from '../core/types/filepath';
 import { SyntaxNode, SyntaxNodeIdGenerator } from '../core/types/nodes';
 import { NodeSymbolIdGenerator, SymbolFactory } from '../core/types/symbol';
-import { DBMLCompletionItemProvider, DBMLDefinitionProvider, DBMLDiagnosticsProvider, DBMLReferencesProvider } from '../services/index';
+import { DBMLCodeActionProvider, DBMLCompletionItemProvider, DBMLDefinitionProvider, DBMLDiagnosticsProvider, DBMLReferencesProvider } from '../services/index';
 import { DbmlProjectLayout } from './projectLayout';
 import { DiagramViewBlock, findDiagramViewBlocks } from './queries/transform';
 import { addDoubleQuoteIfNeeded, escapeString, formatRecordValue, isValidIdentifier, splitQualifiedIdentifier, unescapeString } from './queries/utils';
@@ -30,7 +30,7 @@ export default class Compiler {
     validateFile: (filepath: Filepath) => import('../core/types/report').default<void>;
     nodeFullname: (node: SyntaxNode) => import('../core/types/report').default<string[] | undefined> | import('../core/types/report').default<typeof import('..').UNHANDLED>;
     nodeAlias: (node: SyntaxNode) => import('../core/types/report').default<typeof import('..').UNHANDLED> | import('../core/types/report').default<string | undefined>;
-    nodeSettings: (node: SyntaxNode) => import('../core/types/report').default<typeof import('..').UNHANDLED> | import('../core/types/report').default<import('../core/utils/validate').Settings>;
+    nodeSettings: (node: SyntaxNode) => import('../core/types/report').default<import('../core/utils/validate').Settings> | import('../core/types/report').default<typeof import('..').UNHANDLED>;
     canonicalName: (filepath: Filepath, symbol: import('../core/types/symbol').NodeSymbol) => import('../core/types/report').default<import('./queries/canonicalName').CanonicalName | undefined>;
     bindNode: (node: SyntaxNode) => import('../core/types/report').default<typeof import('..').UNHANDLED> | import('../core/types/report').default<void>;
     bindFile: (filepath: Filepath) => import('../core/types/report').default<void>;
@@ -77,6 +77,9 @@ export default class Compiler {
         newDbml: string;
         edits: import('.').TextEdit[];
     };
+    addSetting: (filepath: Filepath, declaration: SyntaxNode, setting: string) => string | undefined;
+    updateSetting: (filepath: Filepath, declaration: SyntaxNode, settingName: string, newValue: string) => string | undefined;
+    removeSetting: (filepath: Filepath, declaration: SyntaxNode, settingName: string) => string | undefined;
     findDiagramViewBlocks(filepath: Filepath): DiagramViewBlock[];
     readonly token: {
         invalidStream: (filepath: Filepath) => readonly import('..').SyntaxToken[];
@@ -113,5 +116,6 @@ export default class Compiler {
         referenceProvider: DBMLReferencesProvider;
         autocompletionProvider: DBMLCompletionItemProvider;
         diagnosticsProvider: DBMLDiagnosticsProvider;
+        codeActionProvider: DBMLCodeActionProvider;
     };
 }

package/dist/src/compiler/queries/transform/addSetting.d.ts

@@ -0,0 +1,14 @@
+import { SyntaxNode } from '../../../core/types/nodes';
+import { Filepath } from '../../../core/types/filepath';
+import { default as Compiler } from '../../index';
+import { TextEdit } from './applyTextEdits';
+/**
+ * Produces a TextEdit that adds a setting to a field/element declaration.
+ * If the declaration already has a settings block [...], inserts before the closing ].
+ * Otherwise, appends a new [setting] block.
+ */
+export declare function addSettingEdit(declaration: SyntaxNode, setting: string): TextEdit | undefined;
+/**
+ * Adds a setting to a field/element declaration and returns the updated source.
+ */
+export declare function addSetting(this: Compiler, filepath: Filepath, declaration: SyntaxNode, setting: string): string | undefined;

package/dist/src/compiler/queries/transform/index.d.ts

@@ -1,4 +1,6 @@
 export { renameTable } from './renameTable';
 export { syncDiagramView, findDiagramViewBlocks, type DiagramViewSyncOperation, type DiagramViewBlock, } from './syncDiagramView';
 export { applyTextEdits, type TextEdit } from './applyTextEdits';
+export { addSetting, addSettingEdit } from './addSetting';
+export { updateSetting, updateSettingEdit, removeSetting, removeSettingEdit, } from './updateSetting';
 export { type TableNameInput } from './utils';

package/dist/src/compiler/queries/transform/updateSetting.d.ts

@@ -0,0 +1,8 @@
+import { SyntaxNode } from '../../../core/types/nodes';
+import { Filepath } from '../../../core/types/filepath';
+import { default as Compiler } from '../../index';
+import { TextEdit } from './applyTextEdits';
+export declare function updateSettingEdit(declaration: SyntaxNode, settingName: string, newValue: string, source: string): TextEdit | undefined;
+export declare function removeSettingEdit(declaration: SyntaxNode, settingName: string, source: string): TextEdit | undefined;
+export declare function updateSetting(this: Compiler, filepath: Filepath, declaration: SyntaxNode, settingName: string, newValue: string): string | undefined;
+export declare function removeSetting(this: Compiler, filepath: Filepath, declaration: SyntaxNode, settingName: string): string | undefined;

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

@@ -10,6 +10,7 @@ export default class ProgramInterpreter {
     private filepath;
     private errors;
     private warnings;
+    private hints;
     private db;
     constructor(compiler: Compiler, symbol: ProgramSymbol, filepath: Filepath);
     interpret(): Report<SchemaElement | SchemaElement[] | undefined>;
@@ -18,6 +19,7 @@ export default class ProgramInterpreter {
     private interpretAllMetadata;
     private interpretAllAliases;
     private validateRecords;
+    private validatePartialRefs;
     private collectPartialRefs;
     private pushElement;
 }

package/dist/src/core/global_modules/records/utils/constraints/helper.d.ts

@@ -2,25 +2,12 @@ import { default as Compiler } from '../../../../../compiler/index';
 import { CompileWarning } from '../../../../types/errors';
 import { RecordValue, TableRecord } from '../../../../types/schemaJson';
 import { ColumnSymbol } from '../../../../types/symbol';
-export interface ColumnInfo {
-    name: string;
-    pk: boolean;
-    unique: boolean;
-    increment: boolean;
-    notNull: boolean;
-    dbdefault?: {
-        value: string | number;
-        type: string;
-    };
-    typeName: string;
-}
-export declare function columnInfoFromSymbol(col: ColumnSymbol, compiler: Compiler): ColumnInfo;
 export declare function toKeyedRows(record: TableRecord): Record<string, RecordValue>[];
 export declare function makeTableKey(schema: string | null, table: string): string;
-export declare function extractKeyValueWithDefault(row: Record<string, RecordValue>, columnNames: string[], columns?: (ColumnInfo | undefined)[]): string;
-export declare function hasNullWithoutDefaultInKey(row: Record<string, RecordValue>, columnNames: string[], columns?: (ColumnInfo | undefined)[]): boolean;
-export declare function isAutoIncrementColumn(column: ColumnInfo): boolean;
+export declare function extractKeyValueWithDefault(compiler: Compiler, row: Record<string, RecordValue>, columns: ColumnSymbol[]): string;
+export declare function hasNullWithoutDefaultInKey(compiler: Compiler, row: Record<string, RecordValue>, columns: ColumnSymbol[]): boolean;
 export declare function formatFullColumnName(schemaName: string | null, tableName: string, columnName: string): string;
 export declare function formatFullColumnNames(schemaName: string | null, tableName: string, columnNames: string[]): string;
-export declare function formatValues(row: Record<string, RecordValue>, columnNames: string[]): string;
+export declare function formatValues(compiler: Compiler, row: Record<string, RecordValue>, columns: ColumnSymbol[]): string;
+export declare function getDiagnosticAnchorValues(row: Record<string, RecordValue>, columnNames: string[]): RecordValue[];
 export declare function createConstraintWarning(compiler: Compiler, recordValue: RecordValue, message: string): CompileWarning;

package/dist/src/core/global_modules/ref/constraint_fixes.d.ts

@@ -0,0 +1,8 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileInfo } from '../../types/errors';
+import { RefMetadata, PartialRefMetadata } from '../../types/symbol/metadata';
+export declare function validateCardinality(compiler: Compiler, meta: RefMetadata | PartialRefMetadata, side: 'left' | 'right', options?: {
+    allowOtherColFix?: boolean;
+    allowOwnColFix?: boolean;
+}): CompileInfo[];
+export declare function validatePartialRef(compiler: Compiler, meta: PartialRefMetadata): CompileInfo[];

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

@@ -13,5 +13,4 @@ export declare class RefInterpreter {
     private interpretName;
     private interpretBody;
     private validateRefConstraints;
-    private validateCardinalityConstraints;
 }

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

@@ -115,12 +115,17 @@ export declare enum CompileErrorCode {
     CONFLICTING_SETTING = 5004,
     TABLE_REAPPEAR_IN_TABLEGROUP = 5005
 }
+export interface RelatedLocation {
+    nodeOrToken: SyntaxNode | SyntaxToken;
+    message: string;
+}
 export declare class CompileError extends Error {
     code: Readonly<CompileErrorCode>;
     diagnostic: Readonly<string>;
     nodeOrToken: Readonly<SyntaxNode | SyntaxToken>;
     start: Readonly<number>;
     end: Readonly<number>;
+    relatedLocations?: RelatedLocation[];
     constructor(code: number, message: string, nodeOrToken: SyntaxNode | SyntaxToken);
     toWarning(): CompileWarning;
     get filepath(): Filepath;
@@ -131,6 +136,26 @@ export declare class CompileWarning extends Error {
     nodeOrToken: Readonly<SyntaxNode | SyntaxToken>;
     start: Readonly<number>;
     end: Readonly<number>;
+    relatedLocations?: RelatedLocation[];
     constructor(code: number, message: string, nodeOrToken: SyntaxNode | SyntaxToken);
     get filepath(): Filepath;
 }
+export interface QuickFix {
+    title: string;
+    filepath: Filepath;
+    edits: import('../../compiler/queries/transform/applyTextEdits').TextEdit[];
+}
+export declare class CompileInfo extends Error {
+    code: Readonly<CompileErrorCode>;
+    diagnostic: Readonly<string>;
+    nodeOrToken: Readonly<SyntaxNode | SyntaxToken>;
+    start: Readonly<number>;
+    end: Readonly<number>;
+    quickFixes?: QuickFix[];
+    relatedLocations?: RelatedLocation[];
+    constructor(code: number, message: string, nodeOrToken: SyntaxNode | SyntaxToken, options?: {
+        quickFixes?: QuickFix[];
+        relatedLocations?: RelatedLocation[];
+    });
+    get filepath(): Filepath;
+}

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

@@ -13,4 +13,7 @@ export declare const CARDINALITY_SOME: RelationCardinality;
 export declare const CARDINALITY_MANY: RelationCardinality;
 export declare function getMultiplicities(op: string): [RelationCardinality, RelationCardinality] | undefined;
 export declare function getRelationshipOp(left: RelationCardinality, right: RelationCardinality): RelationshipOp;
+export declare function makeCardinalityOptional(rel: RelationCardinality): RelationCardinality;
+export declare function makeCardinalityRequired(rel: RelationCardinality): RelationCardinality;
+export declare function makeCardinalityMany(rel: RelationCardinality): RelationCardinality;
 export {};

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

@@ -1,16 +1,18 @@
-import { CompileError, CompileWarning } from './errors';
+import { CompileError, CompileWarning, CompileInfo } from './errors';
 export default class Report<T> {
     private value;
     private errors;
     private warnings?;
-    static create<T>(value: T, errors?: CompileError[], warnings?: CompileWarning[]): Report<T>;
-    constructor(value: T, errors?: CompileError[], warnings?: CompileWarning[]);
+    private hints?;
+    static create<T>(value: T, errors?: CompileError[], warnings?: CompileWarning[], hints?: CompileInfo[]): Report<T>;
+    constructor(value: T, errors?: CompileError[], warnings?: CompileWarning[], hints?: CompileInfo[]);
     filter<S extends symbol>(filteredValue: S): Report<undefined | Exclude<T, S>>;
     hasValue<S>(value: S): this is Report<S>;
     getFiltered<S extends symbol | undefined | null>(filteredValue: S): Exclude<T, S> | undefined;
     getValue(): T;
     getErrors(): CompileError[];
     getWarnings(): CompileWarning[];
+    getHints(): CompileInfo[];
     chainFiltered<S extends symbol | undefined | null, U>(fn: (_: Exclude<T, S>) => Report<U>, filteredValue: S): Report<U | undefined>;
     chain<U>(fn: (_: T) => Report<U>): Report<U>;
     mapFiltered<S extends symbol | undefined | null, U>(fn: (_: Exclude<T, S>) => U, filteredValue: S): Report<U | undefined>;

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

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './utils';

package/dist/src/core/types/{schemaJson.d.ts → schemaJson/types.d.ts}

@@ -1,7 +1,7 @@
-import { NONE_COLOR } from '../../constants';
-import { Filepath } from './filepath';
-import { Position } from './position';
-import { RelationshipOp, RelationCardinality } from './relation';
+import { NONE_COLOR } from '../../../constants';
+import { Filepath } from '../filepath';
+import { Position } from '../position';
+import { RelationshipOp, RelationCardinality } from '../relation';
 export type Color = `#${string}` | typeof NONE_COLOR;
 export declare enum AliasKind {
     Table = "table"

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

@@ -0,0 +1,3 @@
+import { Column } from './types';
+import { RelationCardinality } from '../relation';
+export declare function inferMultiplicitiesFromColumns(sourceColumn: Pick<Column, 'pk' | 'unique' | 'not_null'>, targetColumn: Pick<Column, 'pk' | 'unique' | 'not_null'>): [RelationCardinality, RelationCardinality];

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

@@ -1,5 +1,6 @@
 import { default as Compiler } from '../../../compiler';
 import { AttributeNode, ElementDeclarationNode, SyntaxNode } from '../nodes';
+import { SyntaxToken } from '../tokens';
 import { ColumnSymbol, NodeSymbol, TablePartialSymbol, TableSymbol } from '../symbol';
 import { Internable } from '../internable';
 import { RelationshipOp, RelationCardinality } from '../relation';
@@ -38,6 +39,7 @@ export declare class RefMetadata extends NodeMetadata {
     leftTable(compiler: Compiler): TableSymbol | undefined;
     rightTable(compiler: Compiler): TableSymbol | undefined;
     op(_compiler: Compiler): RelationshipOp | undefined;
+    opToken(): SyntaxToken | undefined;
     cardinalities(compiler: Compiler): [RelationCardinality, RelationCardinality] | undefined;
     leftCardinality(compiler: Compiler): {
         min: number;
@@ -61,6 +63,7 @@ export declare class PartialRefMetadata extends NodeMetadata {
     leftTablePartial(compiler: Compiler): TablePartialSymbol | undefined;
     rightTable(compiler: Compiler): TableSymbol | TablePartialSymbol | undefined;
     op(_compiler: Compiler): RelationshipOp | undefined;
+    opToken(): SyntaxToken | undefined;
     cardinalities(compiler: Compiler): [RelationCardinality, RelationCardinality] | undefined;
     leftCardinality(compiler: Compiler): {
         min: number;

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

@@ -147,9 +147,12 @@ export declare class ColumnSymbol extends NodeSymbol {
     }, id: NodeSymbolId, filepath: Filepath);
     get canBeImported(): boolean;
     get originalSymbol(): NodeSymbol;
+    qualifiedName(compiler: Compiler): string;
     pk(compiler: Compiler): boolean;
     unique(compiler: Compiler): boolean;
-    nullable(compiler: Compiler): boolean | undefined;
+    nullable(compiler: Compiler): boolean;
+    isNotNullSet(compiler: Compiler): boolean | undefined;
+    isIncrementSet(compiler: Compiler): boolean;
     increment(compiler: Compiler): boolean;
     default(compiler: Compiler): {
         type: 'number' | 'string' | 'boolean' | 'expression';

package/dist/src/index.d.ts

@@ -12,6 +12,7 @@ export type { Position, } from './core/types';
 export { ScopeKind, splitQualifiedIdentifier, unescapeString, escapeString, formatRecordValue, isValidIdentifier, addDoubleQuoteIfNeeded, } from './compiler/index';
 export { type Database, type MasterDatabase, type Table, type Note, type Column, type ColumnType, type Index, type Check, type InlineRef, type Ref, type RefEndpointPair, type RefEndpoint, type Enum, type EnumField, type TableGroup, type TableGroupField, type Alias, type AliasKind, type TablePartial, type TablePartialInjection, type RecordValue, type RecordValueType, type TableRecord, type Project, type SchemaElement, type TokenPosition, type ElementRef, type FilterConfig, type DiagramView, } from './core/types/schemaJson';
 export { type RelationCardinality, type RelationshipOp, getRelationshipOp, getMultiplicities, parseCardinality, CARDINALITY_ONE, CARDINALITY_MAYBE, CARDINALITY_SOME, CARDINALITY_MANY, } from './core/types/relation';
+export { inferMultiplicitiesFromColumns } from './core/types/schemaJson';
 export type { DiagramViewSyncOperation, DiagramViewBlock, TextEdit, } from './compiler/queries/transform';
 export { dbmlLanguageConfig, dbmlMonarchTokensProvider, } from './services/monarch';
 export * from './compiler/projectLayout/layout';

package/dist/src/services/code_actions/provider.d.ts

@@ -0,0 +1,8 @@
+import { default as Compiler } from '../../compiler';
+import { CodeActionProvider, CodeActionList, CodeActionContext, TextModel, Range, CancellationToken } from '../types';
+export default class DBMLCodeActionProvider implements CodeActionProvider {
+    private compiler;
+    constructor(compiler: Compiler);
+    provideCodeActions(model: TextModel, _range: Range, context: CodeActionContext, _token: CancellationToken): CodeActionList | undefined;
+    private quickFixToCodeAction;
+}

package/dist/src/services/diagnostics/provider.d.ts

@@ -1,8 +1,9 @@
 import { default as Compiler } from '../../compiler';
 import { Filepath } from '../../core/types/filepath';
+import { RelatedLocation } from '../../core/types/errors';
 import { MarkerData } from '../types';
 export interface Diagnostic {
-    type: 'error' | 'warning';
+    type: 'error' | 'warning' | 'hint';
     text: string;
     startRow: number;
     startColumn: number;
@@ -10,6 +11,7 @@ export interface Diagnostic {
     endColumn: number;
     code?: string | number;
     filepath: Filepath;
+    relatedLocations?: RelatedLocation[];
 }
 export default class DBMLDiagnosticsProvider {
     private compiler;
@@ -26,6 +28,10 @@ export default class DBMLDiagnosticsProvider {
      * Get only warnings from the current compilation
      */
     provideWarnings(filepath?: Filepath): Diagnostic[];
+    /**
+     * Get only hints from the current compilation
+     */
+    provideHints(filepath?: Filepath): Diagnostic[];
     /**
      * Convert Monaco markers format (for editor integration)
      */

package/dist/src/services/index.d.ts

@@ -1,8 +1,9 @@
+import { default as DBMLCodeActionProvider } from './code_actions/provider';
 import { default as DBMLDefinitionProvider } from './definition/provider';
 import { default as DBMLDiagnosticsProvider } from './diagnostics/provider';
 import { default as DBMLReferencesProvider } from './references/provider';
 import { default as DBMLCompletionItemProvider } from './suggestions/provider';
 export type { Diagnostic } from './diagnostics/provider';
 export * from './types';
-export { DBMLCompletionItemProvider, DBMLDefinitionProvider, DBMLReferencesProvider, DBMLDiagnosticsProvider, };
+export { DBMLCodeActionProvider, DBMLCompletionItemProvider, DBMLDefinitionProvider, DBMLReferencesProvider, DBMLDiagnosticsProvider, };
 export { dbmlMonarchTokensProvider } from './monarch';

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

@@ -62,8 +62,12 @@ export type ColorPresentation = languages.IColorPresentation;
 export type Color = languages.IColor;
 export type DefinitionProvider = languages.DefinitionProvider;
 export type Definition = languages.Definition;
-export type CodeActionList = languages.CodeActionList;
 export type SignatureHelpResult = languages.SignatureHelpResult;
+export type CodeActionProvider = languages.CodeActionProvider;
+export type CodeActionList = languages.CodeActionList;
+export type CodeAction = languages.CodeAction;
+export type CodeActionContext = languages.CodeActionContext;
+export type WorkspaceEdit = languages.WorkspaceEdit;
 export type ReferenceProvider = languages.ReferenceProvider;
 export declare enum MarkerSeverity {
     Hint = 1,

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@dbml/parse",
-  "version": "9.0.0-optional-ref.0",
+  "version": "9.0.0-optional-ref.3",
   "description": "DBML parser v2",
   "author": "Holistics <dev@holistics.io>",
   "license": "Apache-2.0",
@@ -50,5 +50,5 @@
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "01feeb4d524ff11d6cfaad16730a27c73e0d3b1f"
+  "gitHead": "eee148fa544e4826e635b4173e95fb80159b9ce5"
 }