@dbml/parse 5.3.0 → 5.4.0

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

@@ -0,0 +1,66 @@
+import { ProgramNode } from '../core/parser/nodes';
+import { SyntaxToken } from '../core/lexer/tokens';
+import { CompileError } from '../core/errors';
+import { Database } from '../core/interpreter/types';
+import { default as Report } from '../core/report';
+import { DBMLCompletionItemProvider, DBMLDefinitionProvider, DBMLReferencesProvider } from '../services/index';
+import { TextEdit, TableNameInput } from './queries/transform';
+export { ScopeKind } from './types';
+export default class Compiler {
+    private source;
+    private cache;
+    private nodeIdGenerator;
+    private symbolIdGenerator;
+    setSource(source: string): void;
+    private query;
+    private interpret;
+    renameTable(oldName: TableNameInput, newName: TableNameInput): string;
+    applyTextEdits(edits: TextEdit[]): string;
+    readonly token: {
+        invalidStream: () => readonly SyntaxToken[];
+        flatStream: () => readonly SyntaxToken[];
+    };
+    readonly parse: {
+        source: () => Readonly<string>;
+        _: () => Report<{
+            ast: ProgramNode;
+            tokens: SyntaxToken[];
+            rawDb?: Database;
+        }, CompileError>;
+        ast: () => Readonly<ProgramNode>;
+        errors: () => readonly Readonly<CompileError>[];
+        tokens: () => Readonly<SyntaxToken>[];
+        rawDb: () => Readonly<Database> | undefined;
+        publicSymbolTable: () => Readonly<import('../core/analyzer/symbol/symbolTable').default>;
+    };
+    readonly container: {
+        stack: (offset: number) => readonly Readonly<import('../core/parser/nodes').SyntaxNode>[];
+        token: (offset: number) => {
+            token: SyntaxToken;
+            index: number;
+        } | {
+            token: undefined;
+            index: undefined;
+        };
+        element: (offset: number) => Readonly<ProgramNode | import('../core/parser/nodes').ElementDeclarationNode>;
+        scope: (offset: number) => Readonly<import('../core/analyzer/symbol/symbolTable').default> | undefined;
+        scopeKind: (offset: number) => import('./types').ScopeKind;
+    };
+    readonly symbol: {
+        ofName: (nameStack: string[], owner: ProgramNode | import('../core/parser/nodes').ElementDeclarationNode) => {
+            symbol: import('../core/analyzer/symbol/symbols').NodeSymbol;
+            kind: import('../core/analyzer/symbol/symbolIndex').SymbolKind;
+            name: string;
+        }[];
+        members: (ownerSymbol: import('../core/analyzer/symbol/symbols').NodeSymbol) => {
+            symbol: import('../core/analyzer/symbol/symbols').NodeSymbol;
+            name: string;
+            kind: import('../core/analyzer/symbol/symbolIndex').SymbolKind;
+        }[];
+    };
+    initMonacoServices(): {
+        definitionProvider: DBMLDefinitionProvider;
+        referenceProvider: DBMLReferencesProvider;
+        autocompletionProvider: DBMLCompletionItemProvider;
+    };
+}

package/dist/src/compiler/queries/container/element.d.ts

@@ -0,0 +1,3 @@
+import { default as Compiler } from '../../index';
+import { ElementDeclarationNode, ProgramNode } from '../../../core/parser/nodes';
+export declare function containerElement(this: Compiler, offset: number): Readonly<ElementDeclarationNode | ProgramNode>;

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

@@ -0,0 +1,5 @@
+export { containerStack } from './stack';
+export { containerToken } from './token';
+export { containerElement } from './element';
+export { containerScope } from './scope';
+export { containerScopeKind } from './scopeKind';

package/dist/src/compiler/queries/container/scope.d.ts

@@ -0,0 +1,3 @@
+import { default as Compiler } from '../../index';
+import { default as SymbolTable } from '../../../core/analyzer/symbol/symbolTable';
+export declare function containerScope(this: Compiler, offset: number): Readonly<SymbolTable> | undefined;

package/dist/src/compiler/queries/container/scopeKind.d.ts

@@ -0,0 +1,3 @@
+import { default as Compiler } from '../../index';
+import { ScopeKind } from '../../types';
+export declare function containerScopeKind(this: Compiler, offset: number): ScopeKind;

package/dist/src/compiler/queries/container/stack.d.ts

@@ -0,0 +1,3 @@
+import { default as Compiler } from '../../index';
+import { SyntaxNode } from '../../../core/parser/nodes';
+export declare function containerStack(this: Compiler, offset: number): readonly Readonly<SyntaxNode>[];

package/dist/src/compiler/queries/container/token.d.ts

@@ -0,0 +1,9 @@
+import { default as Compiler } from '../../index';
+import { SyntaxToken } from '../../../core/lexer/tokens';
+export declare function containerToken(this: Compiler, offset: number): {
+    token: SyntaxToken;
+    index: number;
+} | {
+    token: undefined;
+    index: undefined;
+};

package/dist/src/compiler/queries/parse.d.ts

@@ -0,0 +1,11 @@
+import { default as Compiler } from '../index';
+import { ProgramNode } from '../../core/parser/nodes';
+import { SyntaxToken } from '../../core/lexer/tokens';
+import { CompileError } from '../../core/errors';
+import { Database } from '../../core/interpreter/types';
+import { default as SymbolTable } from '../../core/analyzer/symbol/symbolTable';
+export declare function ast(this: Compiler): Readonly<ProgramNode>;
+export declare function errors(this: Compiler): readonly Readonly<CompileError>[];
+export declare function tokens(this: Compiler): Readonly<SyntaxToken>[];
+export declare function rawDb(this: Compiler): Readonly<Database> | undefined;
+export declare function publicSymbolTable(this: Compiler): Readonly<SymbolTable>;

package/dist/src/compiler/queries/symbol.d.ts

@@ -0,0 +1,17 @@
+import { default as Compiler } from '../index';
+import { ElementDeclarationNode, ProgramNode } from '../../core/parser/nodes';
+import { NodeSymbol } from '../../core/analyzer/symbol/symbols';
+import { SymbolKind } from '../../core/analyzer/symbol/symbolIndex';
+export declare function symbolMembers(this: Compiler, ownerSymbol: NodeSymbol): {
+    symbol: NodeSymbol;
+    name: string;
+    kind: SymbolKind;
+}[];
+export declare function symbolOfName(this: Compiler, nameStack: string[], owner: ElementDeclarationNode | ProgramNode): {
+    symbol: NodeSymbol;
+    kind: SymbolKind;
+    name: string;
+}[];
+export declare function symbolOfNameToKey(nameStack: string[], owner: {
+    id: number;
+}): string;

package/dist/src/compiler/queries/token.d.ts

@@ -0,0 +1,4 @@
+import { default as Compiler } from '../index';
+import { SyntaxToken } from '../../core/lexer/tokens';
+export declare function flatStream(this: Compiler): readonly SyntaxToken[];
+export declare function invalidStream(this: Compiler): readonly SyntaxToken[];

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

@@ -0,0 +1,13 @@
+export interface TextEdit {
+    start: number;
+    end: number;
+    newText: string;
+}
+/**
+ * Applies a sequence of text edits to a source string.
+ *
+ * @param source - The original source string
+ * @param edits - Array of text edits to apply
+ * @returns The modified source string with all edits applied
+ */
+export declare function applyTextEdits(source: string, edits: TextEdit[]): string;

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

@@ -0,0 +1,2 @@
+export { renameTable, type TableNameInput } from './renameTable';
+export { applyTextEdits, type TextEdit } from './applyTextEdits';

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

@@ -0,0 +1,26 @@
+import { default as Compiler } from '../../index';
+export type TableNameInput = string | {
+    schema?: string;
+    table: string;
+};
+/**
+ * Renames a table in the DBML source code.
+ *
+ * @param oldName - The current table name as string or object (schema defaults to 'public')
+ * @param newName - The new table name as string or object (schema defaults to 'public')
+ * @returns The updated DBML source code with the table renamed
+ *
+ * @example
+ * // String format
+ * compiler.renameTable('users', 'customers');
+ * compiler.renameTable('public.users', 'auth.customers');
+ *
+ * @example
+ * // Object format
+ * compiler.renameTable({ table: 'users' }, { table: 'customers' });
+ * compiler.renameTable(
+ *   { schema: 'auth', table: 'users' },
+ *   { schema: 'auth', table: 'customers' }
+ * );
+ */
+export declare function renameTable(this: Compiler, oldName: TableNameInput, newName: TableNameInput): string;

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

@@ -0,0 +1,13 @@
+export declare const enum ScopeKind {
+    TABLE = 0,
+    ENUM = 1,
+    TABLEGROUP = 2,
+    INDEXES = 3,
+    NOTE = 4,
+    REF = 5,
+    PROJECT = 6,
+    CUSTOM = 7,
+    TOPLEVEL = 8,
+    TABLEPARTIAL = 9,
+    CHECKS = 10
+}

package/dist/src/constants.d.ts

@@ -1,2 +1,3 @@
 export declare const KEYWORDS_OF_DEFAULT_SETTING: readonly string[];
 export declare const NUMERIC_LITERAL_PREFIX: readonly string[];
+export declare const DEFAULT_SCHEMA_NAME = "public";

package/dist/src/{lib → core}/utils.d.ts

@@ -4,6 +4,7 @@ export declare function isAlphaOrUnderscore(char: string): boolean;
 export declare function isDigit(char: string): boolean;
 export declare function isHexChar(char: string): boolean;
 export declare function isAlphaNumeric(char: string): boolean;
+export declare function addQuoteIfNeeded(s: string): string;
 export declare function alternateLists<T, S>(firstList: T[], secondList: S[]): (T | S)[];
 export declare function isOffsetWithinFullSpan(offset: number, nodeOrToken: SyntaxNode | SyntaxToken): boolean;
 export declare function isOffsetWithinSpan(offset: number, nodeOrToken: SyntaxNode | SyntaxToken): boolean;

package/dist/src/index.d.ts

@@ -1,11 +1,12 @@
-import { serialize } from './lib/serialization/serialize';
-import { default as Compiler } from './compiler';
+import { serialize } from './core/serialization/serialize';
+import { default as Compiler } from './compiler/index';
 import * as services from '@/services/index';
-export { ElementKind, } from './lib/analyzer/types';
-export { SyntaxNode, ElementDeclarationNode, ProgramNode, SyntaxNodeKind, type SyntaxNodeId, } from './lib/parser/nodes';
-export { SyntaxToken, SyntaxTokenKind, } from './lib/lexer/tokens';
-export { CompileError, CompileErrorCode, } from './lib/errors';
-export { type Position, } from './lib/types';
-export { ScopeKind, } from './compiler';
-export { type Database, type Table, type Column, type Enum, type Ref, type Project, type TableGroup, type TablePartial, } from './lib/interpreter/types';
+export { ElementKind, } from './core/analyzer/types';
+export { SyntaxNode, ElementDeclarationNode, ProgramNode, SyntaxNodeKind, type SyntaxNodeId, } from './core/parser/nodes';
+export { SyntaxToken, SyntaxTokenKind, } from './core/lexer/tokens';
+export { CompileError, CompileErrorCode, } from './core/errors';
+export { type Position, } from './core/types';
+export { addQuoteIfNeeded, } from './core/utils';
+export { ScopeKind, } from './compiler/index';
+export { type Database, type Table, type Column, type Enum, type Ref, type Project, type TableGroup, type TablePartial, } from './core/interpreter/types';
 export { serialize, Compiler, services };

package/dist/src/services/suggestions/utils.d.ts

@@ -1,6 +1,6 @@
-import { SymbolKind } from '../../lib/analyzer/symbol/symbolIndex';
+import { SymbolKind } from '../../core/analyzer/symbol/symbolIndex';
 import { CompletionItemKind, CompletionList } from '../types';
-import { SyntaxToken } from '../../lib/lexer/tokens';
+import { SyntaxToken } from '../../core/lexer/tokens';
 export declare function pickCompletionItemKind(symbolKind: SymbolKind): CompletionItemKind;
 export declare function shouldPrependSpace(token: SyntaxToken | undefined, offset: number): boolean;
 export declare function noSuggestions(): CompletionList;

package/dist/tests/compiler/applyTextEdits.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/compiler/renameTable.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@dbml/parse",
-  "version": "5.3.0",
+  "version": "5.4.0",
   "description": "DBML parser v2",
   "author": "Holistics <dev@holistics.io>",
   "license": "Apache-2.0",
@@ -54,5 +54,5 @@
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "c8e67b627584b81d18c16a6f2983a92d75a326d9"
+  "gitHead": "e7837a6418602e2b9d5a350335b669155d5c7ad4"
 }

package/dist/src/compiler.d.ts

@@ -1,80 +0,0 @@
-import { SymbolKind } from './lib/analyzer/symbol/symbolIndex';
-import { default as SymbolTable } from './lib/analyzer/symbol/symbolTable';
-import { CompileError } from './lib/errors';
-import { ElementDeclarationNode, ProgramNode, SyntaxNode } from './lib/parser/nodes';
-import { NodeSymbol } from './lib/analyzer/symbol/symbols';
-import { default as Report } from './lib/report';
-import { SyntaxToken } from './lib/lexer/tokens';
-import { Database } from './lib/interpreter/types';
-import { DBMLCompletionItemProvider, DBMLDefinitionProvider, DBMLReferencesProvider } from './services/index';
-export declare const enum ScopeKind {
-    TABLE = 0,
-    ENUM = 1,
-    TABLEGROUP = 2,
-    INDEXES = 3,
-    NOTE = 4,
-    REF = 5,
-    PROJECT = 6,
-    CUSTOM = 7,
-    TOPLEVEL = 8,
-    TABLEPARTIAL = 9,
-    CHECKS = 10
-}
-export default class Compiler {
-    private source;
-    private cache;
-    private nodeIdGenerator;
-    private symbolIdGenerator;
-    private createQuery;
-    setSource(source: string): void;
-    readonly token: {
-        invalidStream: () => readonly SyntaxToken[];
-        flatStream: () => readonly SyntaxToken[];
-    };
-    readonly parse: {
-        source: () => Readonly<string>;
-        _: () => Report<Readonly<{
-            ast: ProgramNode;
-            tokens: SyntaxToken[];
-            rawDb?: Database;
-        }>, CompileError>;
-        ast: () => Readonly<ProgramNode>;
-        errors: () => readonly Readonly<CompileError>[];
-        tokens: () => Readonly<SyntaxToken>[];
-        rawDb: () => Readonly<Database> | undefined;
-        publicSymbolTable: () => Readonly<SymbolTable>;
-    };
-    readonly container: {
-        stack: (arg: number) => readonly Readonly<SyntaxNode>[];
-        token: (arg: number) => {
-            token: SyntaxToken;
-            index: number;
-        } | {
-            token: undefined;
-            index: undefined;
-        };
-        element: (arg: number) => Readonly<ProgramNode | ElementDeclarationNode>;
-        scope: (arg: number) => Readonly<SymbolTable> | undefined;
-        scopeKind: (arg: number) => ScopeKind;
-    };
-    readonly symbol: {
-        ofName: (arg: {
-            nameStack: string[];
-            owner: ElementDeclarationNode | ProgramNode;
-        }) => readonly Readonly<{
-            symbol: NodeSymbol;
-            kind: SymbolKind;
-            name: string;
-        }>[];
-        members: (arg: NodeSymbol) => readonly Readonly<{
-            symbol: NodeSymbol;
-            kind: SymbolKind;
-            name: string;
-        }>[];
-    };
-    initMonacoServices(): {
-        definitionProvider: DBMLDefinitionProvider;
-        referenceProvider: DBMLReferencesProvider;
-        autocompletionProvider: DBMLCompletionItemProvider;
-    };
-}