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

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/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/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.2",
   "description": "DBML parser v2",
   "author": "Holistics <dev@holistics.io>",
   "license": "Apache-2.0",
@@ -50,5 +50,5 @@
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "01feeb4d524ff11d6cfaad16730a27c73e0d3b1f"
+  "gitHead": "3fc818b8e6033e2de577d012722d86a7509e4af3"
 }