@dbml/parse 6.2.0 → 6.3.0-alpha.0

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

@@ -1,11 +1,13 @@
 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 { DBMLCompletionItemProvider, DBMLDefinitionProvider, DBMLReferencesProvider, DBMLDiagnosticsProvider } from '../services/index';
 import { TextEdit, TableNameInput } from './queries/transform';
+import { splitQualifiedIdentifier, unescapeString, escapeString, formatRecordValue, isValidIdentifier, addDoubleQuoteIfNeeded } from './queries/utils';
 export { ScopeKind } from './types';
+export type { TextEdit, TableNameInput };
+export { splitQualifiedIdentifier, unescapeString, escapeString, formatRecordValue, isValidIdentifier, addDoubleQuoteIfNeeded };
 export default class Compiler {
     private source;
     private cache;
@@ -26,9 +28,10 @@ export default class Compiler {
             ast: ProgramNode;
             tokens: SyntaxToken[];
             rawDb?: Database;
-        }, CompileError>;
+        }>;
         ast: () => Readonly<ProgramNode>;
-        errors: () => readonly Readonly<CompileError>[];
+        errors: () => readonly Readonly<import('..').CompileError>[];
+        warnings: () => readonly Readonly<import('../core/errors').CompileWarning>[];
         tokens: () => Readonly<SyntaxToken>[];
         rawDb: () => Readonly<Database> | undefined;
         publicSymbolTable: () => Readonly<import('../core/analyzer/symbol/symbolTable').default>;
@@ -62,5 +65,6 @@ export default class Compiler {
         definitionProvider: DBMLDefinitionProvider;
         referenceProvider: DBMLReferencesProvider;
         autocompletionProvider: DBMLCompletionItemProvider;
+        diagnosticsProvider: DBMLDiagnosticsProvider;
     };
 }

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

@@ -1,11 +1,12 @@
 import { default as Compiler } from '../index';
 import { ProgramNode } from '../../core/parser/nodes';
 import { SyntaxToken } from '../../core/lexer/tokens';
-import { CompileError } from '../../core/errors';
+import { CompileError, CompileWarning } 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 warnings(this: Compiler): readonly Readonly<CompileWarning>[];
 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/transform/index.d.ts

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

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

@@ -1,8 +1,5 @@
 import { default as Compiler } from '../../index';
-export type TableNameInput = string | {
-    schema?: string;
-    table: string;
-};
+import { TableNameInput } from './utils';
 /**
  * Renames a table in the DBML source code.
  *

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

@@ -0,0 +1,22 @@
+import { default as SymbolTable } from '../../../core/analyzer/symbol/symbolTable';
+import { TableSymbol } from '../../../core/analyzer/symbol/symbols';
+export type TableNameInput = string | {
+    schema?: string;
+    table: string;
+};
+/**
+ * Normalizes a table name input to { schema, table } format.
+ * Properly handles quoted identifiers with dots inside.
+ */
+export declare function normalizeTableName(input: TableNameInput): {
+    schema: string;
+    table: string;
+};
+/**
+ * Looks up a table symbol from the symbol table.
+ */
+export declare function lookupTableSymbol(symbolTable: Readonly<SymbolTable>, schema: string, table: string): TableSymbol | null;
+/**
+ * Removes surrounding double quotes from a string if present.
+ */
+export declare function stripQuotes(str: string): string;

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

@@ -0,0 +1,95 @@
+/**
+ * Checks if an identifier is valid (can be used without quotes in DBML).
+ * Valid identifiers must:
+ * - Contain only alphanumeric characters and underscores
+ * - Not start with a digit
+ *
+ * @param name - The identifier to check
+ * @returns True if the identifier is valid and doesn't need quotes
+ *
+ * @example
+ * isValidIdentifier('users') => true
+ * isValidIdentifier('user_name') => true
+ * isValidIdentifier('user name') => false (contains space)
+ * isValidIdentifier('123users') => false (starts with digit)
+ */
+export declare function isValidIdentifier(name: string): boolean;
+/**
+ * Adds double quotes around an identifier if needed.
+ * Identifiers need quotes if they:
+ * - Contain non-alphanumeric characters (except underscore)
+ * - Start with a digit
+ * - Are empty strings
+ *
+ * @param identifier - The identifier to potentially quote
+ * @returns The identifier with double quotes if needed, otherwise unchanged
+ *
+ * @example
+ * addDoubleQuoteIfNeeded('users') => 'users'
+ * addDoubleQuoteIfNeeded('user name') => '"user name"'
+ * addDoubleQuoteIfNeeded('123users') => '"123users"'
+ * addDoubleQuoteIfNeeded('user-name') => '"user-name"'
+ */
+export declare function addDoubleQuoteIfNeeded(identifier: string): string;
+/**
+ * Unescapes a string by processing escape sequences.
+ * Handles escaped quotes (\"), common escape sequences, unicode (\uHHHH), and arbitrary escapes.
+ *
+ * @param str - The string to unescape
+ * @returns The unescaped string
+ *
+ * @example
+ * unescapeString('table\\"name') => 'table"name'
+ * unescapeString('line1\\nline2') => 'line1\nline2'
+ * unescapeString('\\u0041BC') => 'ABC'
+ * unescapeString('\\x') => 'x'
+ */
+export declare function unescapeString(str: string): string;
+/**
+ * Escapes a string by adding backslashes before special characters.
+ * Handles quotes and other characters that need escaping.
+ *
+ * @param str - The string to escape
+ * @returns The escaped string
+ *
+ * @example
+ * escapeString('table"name') => 'table\\"name'
+ * escapeString('line1\nline2') => 'line1\\nline2'
+ */
+export declare function escapeString(str: string): string;
+/**
+ * Formats a record value for DBML output.
+ * Handles different data types and converts them to appropriate DBML syntax.
+ *
+ * @param recordValue - The record value with type information, or a primitive value
+ * @returns The formatted string representation for DBML
+ *
+ * @example
+ * formatRecordValue({ value: 1, type: 'integer' }) => '1'
+ * formatRecordValue({ value: 'Alice', type: 'string' }) => "'Alice'"
+ * formatRecordValue({ value: true, type: 'bool' }) => 'true'
+ * formatRecordValue({ value: null, type: 'string' }) => 'null'
+ * formatRecordValue(undefined) => 'null'
+ * formatRecordValue(null) => 'null'
+ * formatRecordValue('Alice') => "'Alice'"
+ * formatRecordValue(42) => '42'
+ * formatRecordValue(true) => 'true'
+ */
+export declare function formatRecordValue(recordValue: {
+    value: any;
+    type: string;
+} | string | number | boolean | null | undefined): string;
+/**
+ * Splits a qualified identifier string into its components, handling quoted segments.
+ *
+ * Examples:
+ *   - "schema.table" => ["schema", "table"]
+ *   - '"schema name".table' => ["schema name", "table"]
+ *   - '"schema.with.dots"."table.with.dots".column' => ["schema.with.dots", "table.with.dots", "column"]
+ *   - 'schema."table name"."column name"' => ["schema", "table name", "column name"]
+ *   - 'schema . table' => ["schema", "table"]
+ *
+ * @param identifier - The qualified identifier string to split
+ * @returns Array of unquoted identifier components
+ */
+export declare function splitQualifiedIdentifier(identifier: string): string[];

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

@@ -9,5 +9,6 @@ export declare const enum ScopeKind {
     CUSTOM = 7,
     TOPLEVEL = 8,
     TABLEPARTIAL = 9,
-    CHECKS = 10
+    CHECKS = 10,
+    RECORDS = 11
 }

package/dist/src/core/analyzer/analyzer.d.ts

@@ -1,11 +1,10 @@
 import { ProgramNode } from '../parser/nodes';
 import { default as Report } from '../report';
-import { CompileError } from '../errors';
 import { NodeSymbolIdGenerator } from './symbol/symbols';
 export default class Analyzer {
     private ast;
     private symbolFactory;
     constructor(ast: ProgramNode, symbolIdGenerator: NodeSymbolIdGenerator);
-    analyze(): Report<ProgramNode, CompileError>;
-    validate(): Report<ProgramNode, CompileError>;
+    analyze(): Report<ProgramNode>;
+    validate(): Report<ProgramNode>;
 }

package/dist/src/core/analyzer/binder/binder.d.ts

@@ -1,4 +1,3 @@
-import { CompileError } from '../../errors';
 import { ProgramNode } from '../../parser/nodes';
 import { default as Report } from '../../report';
 import { default as SymbolFactory } from '../symbol/factory';
@@ -7,5 +6,5 @@ export default class Binder {
     private symbolFactory;
     constructor(ast: ProgramNode, symbolFactory: SymbolFactory);
     private resolvePartialInjections;
-    resolve(): Report<ProgramNode, CompileError>;
+    resolve(): Report<ProgramNode>;
 }

package/dist/src/core/analyzer/binder/elementBinder/records.d.ts

@@ -0,0 +1,22 @@
+import { SyntaxToken } from '../../../lexer/tokens';
+import { ElementBinder } from '../types';
+import { ElementDeclarationNode, ProgramNode } from '../../../parser/nodes';
+import { CompileError } from '../../../errors';
+import { default as SymbolFactory } from '../../symbol/factory';
+export default class RecordsBinder implements ElementBinder {
+    private symbolFactory;
+    private declarationNode;
+    private ast;
+    private boundColumns;
+    constructor(declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    }, ast: ProgramNode, symbolFactory: SymbolFactory);
+    bind(): CompileError[];
+    private bindRecordsName;
+    private bindTopLevelName;
+    private bindInsideTableName;
+    private bindBody;
+    private bindDataRows;
+    private bindDataRow;
+    private bindSubElements;
+}

package/dist/src/core/analyzer/binder/utils.d.ts

@@ -12,9 +12,10 @@ import { default as TableGroupBinder } from './elementBinder/tableGroup';
 import { default as TablePartialBinder } from './elementBinder/tablePartial';
 import { SymbolKind } from '../symbol/symbolIndex';
 import { CompileError } from '../../errors';
+import { default as RecordsBinder } from './elementBinder/records';
 export declare function pickBinder(element: ElementDeclarationNode & {
     type: SyntaxToken;
-}): typeof ChecksBinder | typeof CustomBinder | typeof EnumBinder | typeof TableBinder | typeof TableGroupBinder | typeof ProjectBinder | typeof RefBinder | typeof NoteBinder | typeof IndexesBinder | typeof TablePartialBinder;
+}): typeof ChecksBinder | typeof CustomBinder | typeof EnumBinder | typeof TableBinder | typeof TableGroupBinder | typeof ProjectBinder | typeof RefBinder | typeof NoteBinder | typeof IndexesBinder | typeof TablePartialBinder | typeof RecordsBinder;
 export declare function scanNonListNodeForBinding(node?: SyntaxNode): {
     variables: (PrimaryExpressionNode & {
         expression: VariableNode;

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

@@ -7,7 +7,8 @@ export declare enum ElementKind {
     Indexes = "indexes",
     TableGroup = "tablegroup",
     TablePartial = "tablepartial",
-    Check = "checks"
+    Check = "checks",
+    Records = "records"
 }
 export declare enum SettingName {
     Color = "color",

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

@@ -1,8 +1,8 @@
 import { Option } from '../option';
 import { ElementDeclarationNode, FunctionExpressionNode, InfixExpressionNode, PrimaryExpressionNode, SyntaxNode, VariableNode } from '../parser/nodes';
+import { SyntaxToken } from '../lexer/tokens';
 import { NodeSymbolIndex } from './symbol/symbolIndex';
 import { NodeSymbol } from './symbol/symbols';
-import { SyntaxToken } from '../lexer/tokens';
 import { ElementKind } from './types';
 export declare function getElementKind(node?: ElementDeclarationNode): Option<ElementKind>;
 export declare function destructureMemberAccessExpression(node?: SyntaxNode): Option<SyntaxNode[]>;
@@ -26,6 +26,8 @@ export declare function extractVarNameFromPrimaryVariable(node?: PrimaryExpressi
     expression: VariableNode;
 }): Option<string>;
 export declare function extractQuotedStringToken(value?: SyntaxNode): Option<string>;
+export declare function extractNumericLiteral(node?: SyntaxNode): number | null;
+export declare function extractReferee(node?: SyntaxNode): NodeSymbol | undefined;
 export declare function isBinaryRelationship(value?: SyntaxNode): value is InfixExpressionNode;
 export declare function isEqualTupleOperands(value: InfixExpressionNode): value is InfixExpressionNode;
 export declare function isValidIndexName(value?: SyntaxNode): value is (PrimaryExpressionNode & {
@@ -38,4 +40,12 @@ export declare function extractIndexName(value: (PrimaryExpressionNode & {
 }) | (FunctionExpressionNode & {
     value: SyntaxToken;
 })): string;
+export declare function destructureCallExpression(node?: SyntaxNode): Option<{
+    variables: (PrimaryExpressionNode & {
+        expression: VariableNode;
+    })[];
+    args: (PrimaryExpressionNode & {
+        expression: VariableNode;
+    })[];
+}>;
 export declare function findSymbol(id: NodeSymbolIndex, startElement: ElementDeclarationNode): NodeSymbol | undefined;

package/dist/src/core/analyzer/validator/elementValidators/records.d.ts

@@ -0,0 +1,26 @@
+import { default as SymbolFactory } from '../../symbol/factory';
+import { CompileError } from '../../../errors';
+import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode } from '../../../parser/nodes';
+import { SyntaxToken } from '../../../lexer/tokens';
+import { ElementValidator } from '../types';
+import { default as SymbolTable } from '../../symbol/symbolTable';
+export default class RecordsValidator implements ElementValidator {
+    private declarationNode;
+    private publicSymbolTable;
+    private symbolFactory;
+    constructor(declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    }, publicSymbolTable: SymbolTable, symbolFactory: SymbolFactory);
+    validate(): CompileError[];
+    private validateContext;
+    private validateName;
+    private validateTopLevelName;
+    private validateInsideTableName;
+    private validateAlias;
+    private validateSettingList;
+    validateBody(body?: FunctionApplicationNode | BlockExpressionNode): CompileError[];
+    private validateDataRows;
+    private validateDataRow;
+    private isValidRecordValue;
+    private validateSubElements;
+}

package/dist/src/core/analyzer/validator/utils.d.ts

@@ -11,12 +11,12 @@ import { default as TableGroupValidator } from './elementValidators/tableGroup';
 import { default as SymbolTable } from '../symbol/symbolTable';
 import { default as SymbolFactory } from '../symbol/factory';
 import { default as Report } from '../../report';
-import { CompileError } from '../../errors';
 import { default as TablePartialValidator } from './elementValidators/tablePartial';
 import { default as ChecksValidator } from './elementValidators/checks';
+import { default as RecordsValidator } from './elementValidators/records';
 export declare function pickValidator(element: ElementDeclarationNode & {
     type: SyntaxToken;
-}): typeof CustomValidator | typeof EnumValidator | typeof TableValidator | typeof TableGroupValidator | typeof ProjectValidator | typeof RefValidator | typeof NoteValidator | typeof IndexesValidator | typeof TablePartialValidator | typeof ChecksValidator;
+}): typeof CustomValidator | typeof EnumValidator | typeof TableValidator | typeof TableGroupValidator | typeof ProjectValidator | typeof RefValidator | typeof NoteValidator | typeof IndexesValidator | typeof TablePartialValidator | typeof ChecksValidator | typeof RecordsValidator;
 export declare function isValidName(nameNode: SyntaxNode): boolean;
 export declare function isValidAlias(aliasNode: SyntaxNode): aliasNode is PrimaryExpressionNode & {
     expression: VariableNode;
@@ -62,4 +62,4 @@ export declare function isTupleOfVariables(value?: SyntaxNode): value is TupleEx
 export declare function isValidColumnType(type: SyntaxNode): boolean;
 export declare function aggregateSettingList(settingList?: ListExpressionNode): Report<{
     [index: string]: AttributeNode[];
-}, CompileError>;
+}>;

package/dist/src/core/analyzer/validator/validator.d.ts

@@ -1,5 +1,4 @@
 import { default as Report } from '../../report';
-import { CompileError } from '../../errors';
 import { ProgramNode } from '../../parser/nodes';
 import { default as SymbolFactory } from '../symbol/factory';
 export default class Validator {
@@ -7,5 +6,5 @@ export default class Validator {
     private publicSchemaSymbol;
     private symbolFactory;
     constructor(ast: ProgramNode, symbolFactory: SymbolFactory);
-    validate(): Report<ProgramNode, CompileError>;
+    validate(): Report<ProgramNode>;
 }

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

@@ -90,6 +90,11 @@ export declare enum CompileErrorCode {
     UNKNOWN_CHECK_SETTING = 3074,
     DUPLICATE_CHECK_SETTING = 3075,
     INVALID_CHECK_SETTING_VALUE = 3076,
+    INVALID_RECORDS_CONTEXT = 3077,
+    INVALID_RECORDS_NAME = 3078,
+    INVALID_RECORDS_FIELD = 3079,
+    DUPLICATE_COLUMN_REFERENCES_IN_RECORDS = 3080,
+    DUPLICATE_RECORDS_FOR_TABLE = 3081,
     BINDING_ERROR = 4000,
     UNSUPPORTED = 5000,
     CIRCULAR_REF = 5001,
@@ -101,7 +106,16 @@ export declare enum CompileErrorCode {
 export declare class CompileError extends Error {
     code: Readonly<CompileErrorCode>;
     diagnostic: Readonly<string>;
-    nodeOrToken: Readonly<SyntaxNode | SyntaxToken | readonly (SyntaxNode | SyntaxToken)[]>;
+    nodeOrToken: Readonly<SyntaxNode | SyntaxToken>;
+    start: Readonly<number>;
+    end: Readonly<number>;
+    constructor(code: number, message: string, nodeOrToken: SyntaxNode | SyntaxToken);
+    toWarning(): CompileWarning;
+}
+export declare class CompileWarning extends Error {
+    code: Readonly<CompileErrorCode>;
+    diagnostic: Readonly<string>;
+    nodeOrToken: Readonly<SyntaxNode | SyntaxToken>;
     start: Readonly<number>;
     end: Readonly<number>;
     constructor(code: number, message: string, nodeOrToken: SyntaxNode | SyntaxToken);

package/dist/src/core/interpreter/interpreter.d.ts

@@ -1,10 +1,9 @@
 import { ProgramNode } from '../parser/nodes';
-import { CompileError } from '../errors';
 import { Database, InterpreterDatabase } from './types';
 import { default as Report } from '../report';
 export default class Interpreter {
     ast: ProgramNode;
     env: InterpreterDatabase;
     constructor(ast: ProgramNode);
-    interpret(): Report<Database, CompileError>;
+    interpret(): Report<Database>;
 }

package/dist/src/core/interpreter/records/index.d.ts

@@ -0,0 +1,10 @@
+import { ElementDeclarationNode } from '../../parser/nodes';
+import { default as Report } from '../../report';
+import { InterpreterDatabase } from '../types';
+export declare class RecordsInterpreter {
+    private env;
+    private tableToRecordMap;
+    constructor(env: InterpreterDatabase);
+    interpret(elements: ElementDeclarationNode[]): Report<void>;
+    private validateConstraints;
+}

package/dist/src/core/interpreter/records/utils/constraints/fk.d.ts

@@ -0,0 +1,3 @@
+import { CompileError } from '../../../../errors';
+import { InterpreterDatabase } from '../../../types';
+export declare function validateForeignKeys(env: InterpreterDatabase): CompileError[];

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

@@ -0,0 +1,10 @@
+import { RecordValue, Column, TableRecordRow } from '../../../types';
+import { CompileError } from '../../../../errors';
+export declare function extractKeyValueWithDefault(row: Record<string, RecordValue>, columnNames: string[], columns?: (Column | undefined)[]): string;
+export declare function hasNullWithoutDefaultInKey(row: Record<string, RecordValue>, columnNames: string[], columns?: (Column | undefined)[]): boolean;
+export declare function isAutoIncrementColumn(column: Column): boolean;
+export declare function hasNotNullWithDefault(column: Column): 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 createConstraintErrors(row: TableRecordRow, columnNames: string[], message: string): CompileError[];

package/dist/src/core/interpreter/records/utils/constraints/index.d.ts

@@ -0,0 +1,3 @@
+export * from './pk';
+export * from './unique';
+export * from './fk';

package/dist/src/core/interpreter/records/utils/constraints/pk.d.ts

@@ -0,0 +1,3 @@
+import { CompileError } from '../../../../errors';
+import { InterpreterDatabase } from '../../../types';
+export declare function validatePrimaryKey(env: InterpreterDatabase): CompileError[];

package/dist/src/core/interpreter/records/utils/constraints/unique.d.ts

@@ -0,0 +1,3 @@
+import { CompileError } from '../../../../errors';
+import { InterpreterDatabase } from '../../../types';
+export declare function validateUnique(env: InterpreterDatabase): CompileError[];

package/dist/src/core/interpreter/records/utils/data/index.d.ts

@@ -0,0 +1,2 @@
+export * from './sqlTypes';
+export * from './values';

package/dist/src/core/interpreter/records/utils/data/sqlTypes.d.ts

@@ -0,0 +1,19 @@
+import { ColumnSymbol } from '../../../../analyzer/symbol/symbols';
+export type SqlDialect = 'mysql' | 'postgres' | 'mssql' | 'oracle' | 'snowflake';
+export declare function normalizeTypeName(type: string): string;
+export declare function isIntegerType(type: string, dialect?: SqlDialect): boolean;
+export declare function isFloatType(type: string, dialect?: SqlDialect): boolean;
+export declare function isNumericType(type: string, dialect?: SqlDialect): boolean;
+export declare function isBooleanType(type: string, dialect?: SqlDialect): boolean;
+export declare function isStringType(type: string, dialect?: SqlDialect): boolean;
+export declare function isBinaryType(type: string, dialect?: SqlDialect): boolean;
+export declare function isDateTimeType(type: string, dialect?: SqlDialect): boolean;
+export declare function isSerialType(type: string, dialect?: SqlDialect): boolean;
+export declare function getNumericTypeParams(columnSymbol: ColumnSymbol): {
+    precision?: number;
+    scale?: number;
+};
+export declare function getLengthTypeParam(columnSymbol: ColumnSymbol): {
+    length?: number;
+};
+export declare function getRecordValueType(sqlType: string, isEnum: boolean): string;

package/dist/src/core/interpreter/records/utils/data/values.d.ts

@@ -0,0 +1,14 @@
+import { FunctionExpressionNode, SyntaxNode } from '../../../../parser/nodes';
+export { extractNumericLiteral } from '../../../../analyzer/utils';
+export declare function isNullish(value: SyntaxNode): boolean;
+export declare function isEmptyStringLiteral(value: SyntaxNode): boolean;
+export declare function isFunctionExpression(value: SyntaxNode): value is FunctionExpressionNode;
+export declare function extractSignedNumber(node: SyntaxNode): number | null;
+export declare function tryExtractNumeric(value: SyntaxNode | number | string | boolean | undefined | null): number | null;
+export declare function tryExtractInteger(value: SyntaxNode | number | string | boolean | undefined | null): number | null;
+export declare const TRUTHY_VALUES: string[];
+export declare const FALSY_VALUES: string[];
+export declare function tryExtractBoolean(value: SyntaxNode | number | string | boolean | undefined | null): boolean | null;
+export declare function tryExtractEnum(value: SyntaxNode | string | undefined | null): string | null;
+export declare function tryExtractString(value: SyntaxNode | string | boolean | number | undefined | null): string | null;
+export declare function tryExtractDateTime(value: SyntaxNode | string | undefined | null): string | null;

package/dist/src/core/interpreter/records/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './data';
+export * from './constraints';

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

@@ -1,4 +1,4 @@
-import { ElementDeclarationNode } from '../parser/nodes';
+import { ElementDeclarationNode, FunctionApplicationNode, SyntaxNode } from '../parser/nodes';
 import { Position } from '../types';
 import { CompileError } from '../errors';
 export interface TokenPosition {
@@ -24,6 +24,34 @@ export interface InterpreterDatabase {
     tablePartials: Map<ElementDeclarationNode, TablePartial>;
     aliases: Alias[];
     project: Map<ElementDeclarationNode, Project>;
+    records: Map<Table, TableRecordRow[]>;
+    recordsElements: ElementDeclarationNode[];
+    cachedMergedTables: Map<Table, Table>;
+    source: string;
+}
+export type RecordValueType = 'string' | 'bool' | 'integer' | 'real' | 'date' | 'time' | 'datetime' | string;
+export interface RecordValue {
+    value: any;
+    type: RecordValueType;
+}
+export interface TableRecordRow {
+    values: Record<string, {
+        value: any;
+        type: RecordValueType;
+        node?: SyntaxNode;
+    }>;
+    node: FunctionApplicationNode;
+    columnNodes: Record<string, SyntaxNode>;
+}
+export interface TableRecordsData {
+    table: Table;
+    rows: TableRecordRow[];
+}
+export interface TableRecord {
+    schemaName: string | undefined;
+    tableName: string;
+    columns: string[];
+    values: RecordValue[][];
 }
 export interface Database {
     schemas: [];
@@ -35,6 +63,7 @@ export interface Database {
     aliases: Alias[];
     project: Project;
     tablePartials: TablePartial[];
+    records: TableRecord[];
 }
 export interface Table {
     name: string;
@@ -61,6 +90,14 @@ export interface ColumnType {
     schemaName: string | null;
     type_name: string;
     args: string | null;
+    numericParams?: {
+        precision: number;
+        scale: number;
+    };
+    lengthParam?: {
+        length: number;
+    };
+    isEnum?: boolean;
 }
 export interface Column {
     name: string;
@@ -193,5 +230,5 @@ export type Project = Record<string, never> | {
         token: TokenPosition;
     };
     token: TokenPosition;
-    [index: string & Omit<any, 'name' | 'tables' | 'refs' | 'enums' | 'tableGroups' | 'note' | 'tablePartials'>]: string;
+    [index: string & Omit<any, 'name' | 'tables' | 'refs' | 'enums' | 'tableGroups' | 'note' | 'tablePartials' | 'records'>]: string;
 };

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

@@ -1,9 +1,8 @@
 import { ColumnSymbol } from '../analyzer/symbol/symbols';
 import { LiteralNode, PrimaryExpressionNode, SyntaxNode } from '../parser/nodes';
-import { ColumnType, RelationCardinality, Table, TokenPosition } from './types';
+import { ColumnType, RelationCardinality, Table, TokenPosition, InterpreterDatabase, Ref } from './types';
 import { SyntaxTokenKind } from '../lexer/tokens';
 import { default as Report } from '../report';
-import { CompileError } from '../errors';
 export declare function extractNamesFromRefOperand(operand: SyntaxNode, owner?: Table): {
     schemaName: string | null;
     tableName: string;
@@ -32,4 +31,6 @@ export declare function processDefaultValue(valueNode?: SyntaxNode): {
     type: 'string' | 'number' | 'boolean' | 'expression';
     value: string | number;
 } | undefined;
-export declare function processColumnType(typeNode: SyntaxNode): Report<ColumnType, CompileError>;
+export declare function processColumnType(typeNode: SyntaxNode, env: InterpreterDatabase): Report<ColumnType>;
+export declare function mergeTableAndPartials(table: Table, env: InterpreterDatabase): Table;
+export declare function extractInlineRefsFromTablePartials(table: Table, env: InterpreterDatabase): Ref[];

package/dist/src/core/lexer/lexer.d.ts

@@ -1,4 +1,3 @@
-import { CompileError } from '../errors';
 import { default as Report } from '../report';
 import { SyntaxToken, SyntaxTokenKind } from './tokens';
 export default class Lexer {
@@ -15,7 +14,7 @@ export default class Lexer {
     match(sequence: string): boolean;
     private addToken;
     private createToken;
-    lex(): Report<SyntaxToken[], CompileError>;
+    lex(): Report<SyntaxToken[]>;
     scanTokens(): void;
     gatherTrivia(): void;
     gatherInvalid(): void;