sqlmesh 0.196.4.dev4__tar.gz → 0.196.4.dev6__tar.gz

sqlmesh-0.196.4.dev6/CLAUDE.md

@@ -0,0 +1,351 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+SQLMesh is a next-generation data transformation framework that enables:
+- Virtual data environments for isolated development without warehouse costs
+- Plan/apply workflow (like Terraform) for safe deployments
+- Multi-dialect SQL support with automatic transpilation
+- Incremental processing to run only necessary transformations
+- Built-in testing and CI/CD integration
+
+**Requirements**: Python >= 3.9 (Note: Python 3.13+ is not yet supported)
+
+## Essential Commands
+
+### Environment setup
+```bash
+# Create and activate a Python virtual environment (Python >= 3.9, < 3.13)
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+
+# Install development dependencies
+make install-dev
+
+# Setup pre-commit hooks (important for code quality)
+make install-pre-commit
+```
+
+### Common Development Tasks
+```bash
+# Run linters and formatters (ALWAYS run before committing)
+make style
+
+# Fast tests for quick feedback during development
+make fast-test
+
+# Slow tests for comprehensive coverage
+make slow-test
+
+# Run specific test file
+pytest tests/core/test_context.py -v
+
+# Run tests with specific marker
+pytest -m "not slow and not docker" -v
+
+# Build package
+make package
+
+# Serve documentation locally
+make docs-serve
+```
+
+### Engine-Specific Testing
+```bash
+# DuckDB (default, no setup required)
+make duckdb-test
+
+# Other engines require credentials/Docker
+make snowflake-test  # Needs SNOWFLAKE_* env vars
+make bigquery-test   # Needs GOOGLE_APPLICATION_CREDENTIALS
+make databricks-test # Needs DATABRICKS_* env vars
+```
+
+### UI Development
+```bash
+# In web/client directory
+pnpm run dev   # Start development server
+pnpm run build # Production build
+pnpm run test  # Run tests
+
+# Docker-based UI
+make ui-up     # Start UI in Docker
+make ui-down   # Stop UI
+```
+
+## Architecture Overview
+
+### Core Components
+
+**sqlmesh/core/context.py**: The main Context class orchestrates all SQLMesh operations. This is the entry point for understanding how models are loaded, plans are created, and executions happen.
+
+**sqlmesh/core/model/**: Model definitions and kinds (FULL, INCREMENTAL_BY_TIME_RANGE, SCD_TYPE_2, etc.). Each model kind has specific behaviors for how data is processed.
+
+**sqlmesh/core/snapshot/**: The versioning system. Snapshots are immutable versions of models identified by fingerprints. Understanding snapshots is crucial for how SQLMesh tracks changes.
+
+**sqlmesh/core/plan/**: Plan building and evaluation logic. Plans determine what changes need to be applied and in what order.
+
+**sqlmesh/core/engine_adapter/**: Database engine adapters provide a unified interface across 16+ SQL engines. Each adapter handles engine-specific SQL generation and execution.
+
+### Key Concepts
+
+1. **Virtual Environments**: Lightweight branches that share unchanged data between environments, reducing storage costs and deployment time.
+
+2. **Fingerprinting**: Models are versioned using content-based fingerprints. Any change to a model's logic creates a new version.
+
+3. **State Sync**: Manages metadata across different backends (can be stored in the data warehouse or external databases).
+
+4. **Intervals**: Time-based partitioning system for incremental models, tracking what data has been processed.
+
+## Testing Philosophy
+
+- Tests are marked with pytest markers:
+  - **Type markers**: `fast`, `slow`, `docker`, `remote`, `cicdonly`, `isolated`, `registry_isolation`
+  - **Domain markers**: `cli`, `dbt`, `github`, `jupyter`, `web`
+  - **Engine markers**: `engine`, `athena`, `bigquery`, `clickhouse`, `databricks`, `duckdb`, `motherduck`, `mssql`, `mysql`, `postgres`, `redshift`, `snowflake`, `spark`, `trino`, `risingwave`
+- Default to `fast` tests during development
+- Engine tests use real connections when available, mocks otherwise
+- The `sushi` example project is used extensively in tests
+- Use `DuckDBMetadata` helper for validating table metadata in tests
+- Tests run in parallel by default (`pytest -n auto`)
+
+## Code Style Guidelines
+
+- Python: Black formatting, isort for imports, mypy for type checking, Ruff for linting
+- TypeScript/React: ESLint + Prettier configuration
+- SQL: SQLGlot handles parsing/formatting
+- All style checks run via `make style`
+- Pre-commit hooks enforce all style rules automatically
+- Important: Some modules (duckdb, numpy, pandas) are banned at module level to prevent import-time side effects
+
+## Important Files
+
+- `sqlmesh/core/context.py`: Main orchestration class
+- `examples/sushi/`: Reference implementation used in tests
+- `web/server/main.py`: Web UI backend entry point
+- `web/client/src/App.tsx`: Web UI frontend entry point
+- `vscode/extension/src/extension.ts`: VSCode extension entry point
+
+## Common Pitfalls
+
+1. **Engine Tests**: Many tests require specific database credentials or Docker. Check test markers before running.
+
+2. **Path Handling**: Be careful with Windows paths - use `pathlib.Path` for cross-platform compatibility.
+
+3. **State Management**: Understanding the state sync mechanism is crucial for debugging environment issues.
+
+4. **Snapshot Versioning**: Changes to model logic create new versions - this is by design for safe deployments.
+
+5. **Module Imports**: Avoid importing duckdb, numpy, or pandas at module level - these are banned by Ruff to prevent long load times in cases where the libraries aren't used.
+
+## GitHub CI/CD Bot Architecture
+
+SQLMesh includes a GitHub CI/CD bot integration that automates data transformation workflows. The implementation is located in `sqlmesh/integrations/github/` and follows a clean architectural pattern.
+
+### Code Organization
+
+**Core Integration Files:**
+- `sqlmesh/cicd/bot.py`: Main CLI entry point (`sqlmesh_cicd` command)
+- `sqlmesh/integrations/github/cicd/controller.py`: Core bot orchestration logic
+- `sqlmesh/integrations/github/cicd/command.py`: Individual command implementations
+- `sqlmesh/integrations/github/cicd/config.py`: Configuration classes and validation
+
+### Architecture Pattern
+
+The bot follows a **Command Pattern** architecture:
+
+1. **CLI Layer** (`bot.py`): Handles argument parsing and delegates to controllers
+2. **Controller Layer** (`controller.py`): Orchestrates workflow execution and manages state
+3. **Command Layer** (`command.py`): Implements individual operations (test, deploy, plan, etc.)
+4. **Configuration Layer** (`config.py`): Manages bot configuration and validation
+
+### Key Components
+
+**GitHubCICDController**: Main orchestrator that:
+- Manages GitHub API interactions via PyGithub
+- Coordinates workflow execution across different commands
+- Handles error reporting through GitHub Check Runs
+- Manages PR comment interactions and status updates
+
+**Command Implementations**:
+- `run_tests()`: Executes unit tests with detailed reporting
+- `update_pr_environment()`: Creates/updates virtual PR environments
+- `gen_prod_plan()`: Generates production deployment plans
+- `deploy_production()`: Handles production deployments
+- `check_required_approvers()`: Validates approval requirements
+
+**Configuration Management**:
+- Uses Pydantic models for type-safe configuration
+- Supports both YAML config files and environment variables
+- Validates bot settings and user permissions
+- Handles approval workflows and deployment triggers
+
+### Integration with Core SQLMesh
+
+The bot leverages core SQLMesh components:
+- **Context**: Uses SQLMesh Context for project operations
+- **Plan/Apply**: Integrates with SQLMesh's plan generation and application
+- **Virtual Environments**: Creates isolated PR environments using SQLMesh's virtual data environments
+- **State Sync**: Manages metadata synchronization across environments
+- **Testing Framework**: Executes SQLMesh unit tests and reports results
+
+### Error Handling and Reporting
+
+- **GitHub Check Runs**: Creates detailed status reports for each workflow step
+- **PR Comments**: Provides user-friendly feedback on failures and successes
+- **Structured Logging**: Uses SQLMesh's logging framework for debugging
+- **Exception Handling**: Graceful handling of GitHub API failures and SQLMesh errors
+
+## Environment Variables for Engine Testing
+
+When running engine-specific tests, these environment variables are required:
+
+- **Snowflake**: `SNOWFLAKE_ACCOUNT`, `SNOWFLAKE_WAREHOUSE`, `SNOWFLAKE_DATABASE`, `SNOWFLAKE_USER`, `SNOWFLAKE_PASSWORD`
+- **BigQuery**: `BIGQUERY_KEYFILE` or `GOOGLE_APPLICATION_CREDENTIALS`
+- **Databricks**: `DATABRICKS_CATALOG`, `DATABRICKS_SERVER_HOSTNAME`, `DATABRICKS_HTTP_PATH`, `DATABRICKS_ACCESS_TOKEN`, `DATABRICKS_CONNECT_VERSION`
+- **Redshift**: `REDSHIFT_HOST`, `REDSHIFT_USER`, `REDSHIFT_PASSWORD`, `REDSHIFT_DATABASE`
+- **Athena**: `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `ATHENA_S3_WAREHOUSE_LOCATION`
+- **ClickHouse Cloud**: `CLICKHOUSE_CLOUD_HOST`, `CLICKHOUSE_CLOUD_USERNAME`, `CLICKHOUSE_CLOUD_PASSWORD`
+
+## Migrations System
+
+SQLMesh uses a migration system to evolve its internal state database schema and metadata format. The migrations handle changes to SQLMesh's internal structure, not user data transformations.
+
+### Migration Structure
+
+**Location**: `sqlmesh/migrations/` - Contains 80+ migration files from v0001 to v0083+
+
+**Naming Convention**: `v{XXXX}_{descriptive_name}.py` (e.g., `v0001_init.py`, `v0083_use_sql_for_scd_time_data_type_data_hash.py`)
+
+**Core Infrastructure**:
+- `sqlmesh/core/state_sync/db/migrator.py`: Main migration orchestrator
+- `sqlmesh/utils/migration.py`: Cross-database compatibility utilities
+- `sqlmesh/core/state_sync/base.py`: Auto-discovery and loading logic
+
+### Migration Categories
+
+**Schema Evolution**:
+- State table creation/modification (snapshots, environments, intervals)
+- Column additions/removals and index management
+- Database engine compatibility fixes (MySQL/MSSQL field size limits)
+
+**Data Format Migrations**:
+- JSON metadata structure updates (snapshot serialization changes)
+- Path normalization (Windows compatibility)
+- Fingerprint recalculation when SQLGlot parsing changes
+
+**Cleanup Operations**:
+- Removing obsolete tables and unused data
+- Metadata optimization and attribute cleanup
+
+### Key Migration Patterns
+
+```python
+# Standard migration function signature
+def migrate(state_sync, **kwargs):  # type: ignore
+    engine_adapter = state_sync.engine_adapter
+    schema = state_sync.schema
+    # Migration logic here
+
+# Common operations
+engine_adapter.create_state_table(table_name, columns_dict)
+engine_adapter.alter_table(alter_expression)
+engine_adapter.drop_table(table_name)
+```
+
+### State Management Integration
+
+**Core State Tables**:
+- `_snapshots`: Model version metadata (most frequently migrated)
+- `_environments`: Environment definitions
+- `_versions`: Schema/SQLGlot/SQLMesh version tracking
+- `_intervals`: Incremental processing metadata
+
+**Migration Safety**:
+- Automatic backups before migration (unless `skip_backup=True`)
+- Atomic database transactions for consistency
+- Snapshot count validation before/after migrations
+- Automatic rollback on failures
+
+### Migration Execution
+
+**Auto-Discovery**: Migrations are automatically loaded using `pkgutil.iter_modules()`
+
+**Triggers**: Migrations run automatically when:
+- Schema version mismatch detected
+- SQLGlot version changes require fingerprint recalculation
+- Manual `sqlmesh migrate` command execution
+
+**Execution Flow**:
+1. Version comparison (local vs remote schema)
+2. Backup creation of state tables
+3. Sequential migration execution (numerical order)
+4. Snapshot fingerprint recalculation if needed  
+5. Environment updates with new snapshot references
+
+## dbt Integration
+
+SQLMesh provides native support for dbt projects, allowing users to run existing dbt projects while gaining access to SQLMesh's advanced features like virtual environments and plan/apply workflows.
+
+### Core dbt Integration
+
+**Location**: `sqlmesh/dbt/` - Complete dbt integration architecture
+
+**Key Components**:
+- `sqlmesh/dbt/loader.py`: Main dbt project loader extending SQLMesh's base loader
+- `sqlmesh/dbt/manifest.py`: dbt manifest parsing and project discovery
+- `sqlmesh/dbt/adapter.py`: dbt adapter system for SQL execution and schema operations
+- `sqlmesh/dbt/model.py`: dbt model configurations and materialization mapping
+- `sqlmesh/dbt/context.py`: dbt project context and environment management
+
+### Project Conversion
+
+**dbt Converter**: `sqlmesh/dbt/converter/` - Tools for migrating dbt projects to SQLMesh
+
+**Key Features**:
+- `convert.py`: Main conversion orchestration
+- `jinja.py` & `jinja_transforms.py`: Jinja template and macro conversion
+- Full support for dbt assets (models, seeds, sources, tests, snapshots, macros)
+
+**CLI Commands**:
+```bash
+# Initialize SQLMesh in existing dbt project
+sqlmesh init -t dbt
+
+# Convert dbt project to SQLMesh format
+sqlmesh dbt convert
+```
+
+### Supported dbt Features
+
+**Project Structure**:
+- Full dbt project support (models, seeds, sources, tests, snapshots, macros)
+- dbt package dependencies and version management
+- Profile integration using existing `profiles.yml` for connections
+
+**Materializations**:
+- All standard dbt materializations (table, view, incremental, ephemeral)
+- Incremental model strategies (delete+insert, merge, insert_overwrite)
+- SCD Type 2 support and snapshot strategies
+
+**Advanced Features**:
+- Jinja templating with full macro support
+- Runtime variable passing and configuration
+- dbt test integration and execution
+- Cross-database compatibility with SQLMesh's multi-dialect support
+
+### Example Projects
+
+**sushi_dbt**: `examples/sushi_dbt/` - Complete dbt project running with SQLMesh
+**Test Fixtures**: `tests/fixtures/dbt/sushi_test/` - Comprehensive test dbt project with all asset types
+
+### Integration Benefits
+
+When using dbt with SQLMesh, you gain:
+- **Virtual Environments**: Isolated development without warehouse costs
+- **Plan/Apply Workflow**: Safe deployments with change previews
+- **Multi-Dialect Support**: Run the same dbt project across different SQL engines
+- **Advanced Testing**: Enhanced testing capabilities beyond standard dbt tests
+- **State Management**: Sophisticated metadata and versioning system

{sqlmesh-0.196.4.dev4 → sqlmesh-0.196.4.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.196.4.dev4
+Version: 0.196.4.dev6
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License

{sqlmesh-0.196.4.dev4 → sqlmesh-0.196.4.dev6}/sqlmesh/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.196.4.dev4'
-__version_tuple__ = version_tuple = (0, 196, 4, 'dev4')
+__version__ = version = '0.196.4.dev6'
+__version_tuple__ = version_tuple = (0, 196, 4, 'dev6')

{sqlmesh-0.196.4.dev4 → sqlmesh-0.196.4.dev6}/sqlmesh.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.196.4.dev4
+Version: 0.196.4.dev6
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License

{sqlmesh-0.196.4.dev4 → sqlmesh-0.196.4.dev6}/sqlmesh.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@
 .prettierignore
 .prettierrc.cjs
 .readthedocs.yaml
+CLAUDE.md
 LICENSE
 MANIFEST.in
 Makefile
@@ -727,6 +728,7 @@ vscode/openapi.json
 vscode/bus/.gitignore
 vscode/bus/package.json
 vscode/bus/tsconfig.json
+vscode/bus/src/brand.ts
 vscode/bus/src/callbacks.ts
 vscode/bus/src/result.ts
 vscode/extension/.gitignore
@@ -841,6 +843,7 @@ vscode/react/src/components/sourceList/SourceListItem.tsx
 vscode/react/src/components/title/Title.tsx
 vscode/react/src/domain/initial.ts
 vscode/react/src/domain/lineage.ts
+vscode/react/src/domain/models.ts
 vscode/react/src/domain/sqlmesh-model.ts
 vscode/react/src/hooks/eventBus.tsx
 vscode/react/src/hooks/vscode.ts

sqlmesh-0.196.4.dev6/vscode/bus/src/brand.ts

@@ -0,0 +1,19 @@
+declare const __brand: unique symbol
+type Brand<B> = { [__brand]: B }
+
+/**
+ * Branded is a type that adds a brand to a type. It is a type that is used to
+ * ensure that the type is unique and that it is not possible to mix up types
+ * with the same brand.
+ *
+ * @example
+ *
+ * type UserId = Branded<string, 'UserId'>
+ * type UserName = Branded<string, 'UserName'>
+ *
+ * const userId = '123' as UserId
+ * const userName = 'John Doe' as UserName
+ *
+ * userId == userName -> compile error
+ */
+export type Branded<T, B> = T & Brand<B>

{sqlmesh-0.196.4.dev4 → sqlmesh-0.196.4.dev6}/vscode/react/src/components/graph/ModelColumns.tsx

@@ -46,6 +46,7 @@ import { Popover, Transition } from '@headlessui/react'
 import { useApiColumnLineage } from '@/api/index'
 import SourceList from '@/components/sourceList/SourceList'
 import type { Lineage } from '@/domain/lineage'
+import type { ModelName } from '@/domain/models'
 
 export default function ModelColumns({
   nodeId,
@@ -732,5 +733,5 @@ function getColumnFromLineage(
   nodeId: string,
   columnName: string,
 ): LineageColumn | undefined {
-  return lineage?.[nodeId]?.columns?.[encodeURI(columnName)]
+  return lineage?.[nodeId]?.columns?.[encodeURI(columnName) as ModelName]
 }

{sqlmesh-0.196.4.dev4 → sqlmesh-0.196.4.dev6}/vscode/react/src/components/graph/help.ts

@@ -17,6 +17,7 @@ import {
 } from './ModelNode'
 import type { Lineage } from '@/domain/lineage'
 import type { ConnectedNode } from '@/workers/lineage'
+import type { ModelEncodedFQN, ModelName } from '@/domain/models'
 
 export interface GraphNodeData {
   label: string
@@ -108,7 +109,7 @@ function getEdges(lineage: Record<string, Lineage> = {}): Edge[] {
     })
 
     for (const targetColumnName in targetModel.columns) {
-      const sourceModel = targetModel.columns[targetColumnName]
+      const sourceModel = targetModel.columns[targetColumnName as ModelName]
 
       if (isNil(sourceModel) || isNil(sourceModel.models)) continue
 
@@ -210,7 +211,7 @@ function getNodeMap({
       node.targetPosition = Position.Left
     }
 
-    if (sources.has(node.id)) {
+    if (sources.has(node.id as ModelEncodedFQN)) {
       node.sourcePosition = Position.Right
     }
 
@@ -343,7 +344,7 @@ function mergeLineageWithColumns(
       }
 
       // New Column Lineage delivers fresh data, so we can just assign it
-      currentLineageModel.columns[targetColumnNameEncoded] = {
+      currentLineageModel.columns[targetColumnNameEncoded as ModelName] = {
         expression: newLineageModelColumn.expression,
         source: newLineageModelColumn.source,
         models: {},
@@ -353,7 +354,7 @@ function mergeLineageWithColumns(
       if (isObjectEmpty(newLineageModelColumn.models)) continue
 
       const currentLineageModelColumn =
-        currentLineageModel.columns[targetColumnNameEncoded]!
+        currentLineageModel.columns[targetColumnNameEncoded as ModelName]!
       const currentLineageModelColumnModels = currentLineageModelColumn.models
 
       for (const sourceColumnName in newLineageModelColumn.models) {
@@ -371,7 +372,7 @@ function mergeLineageWithColumns(
                   newLineageModelColumnModel,
                 ),
           ),
-        ).map(encodeURI)
+        ).map((uri: string) => encodeURI(uri))
       }
     }
   }
@@ -481,7 +482,7 @@ function getLineageIndex(lineage: Record<string, Lineage> = {}): string {
 
       if (isNotNil(columns)) {
         Object.keys(columns).forEach(columnName => {
-          const column = columns[columnName]
+          const column = columns[columnName as ModelName]
 
           if (isNotNil(column) && isNotNil(column.models)) {
             Object.keys(column.models).forEach(m => allModels.add(m))

sqlmesh-0.196.4.dev6/vscode/react/src/domain/lineage.ts

@@ -0,0 +1,7 @@
+import { type LineageColumn } from '@/api/client'
+import type { ModelEncodedFQN, ModelName } from '@/domain/models'
+
+export interface Lineage {
+  models: ModelEncodedFQN[]
+  columns?: Record<ModelName, LineageColumn>
+}

sqlmesh-0.196.4.dev6/vscode/react/src/domain/models.ts

@@ -0,0 +1,43 @@
+import type { Branded } from '@bus/brand'
+
+/**
+ * ModelName is a type that represents the name of a model.
+ */
+export type ModelName = Branded<string, 'ModelName'>
+
+/**
+ * ModelEncodedName is a type that represents the encoded name of a model.
+ */
+export type ModelEncodedName = Branded<string, 'ModelEncodedName'>
+
+/**
+ * ModelFQN is a type that represents the fully qualified name of a model.
+ */
+export type ModelFQN = Branded<string, 'ModelFQN'>
+
+/**
+ * ModelEncodedFQN is a type that represents the encoded fully qualified name of a model.
+ */
+export type ModelEncodedFQN = Branded<string, 'ModelEncodedFQN'>
+
+/**
+ * ModelURI is a type that represents the URI of a model.
+ */
+export type ModelURI = Branded<string, 'ModelURI'>
+
+/**
+ * ModelEncodedURI is a type that represents the encoded URI of a model.
+ */
+export type ModelEncodedURI = Branded<string, 'ModelEncodedURI'>
+
+/**
+ * ModelPath is a type that represents the path of a model.
+ * A model path is relative to the project root.
+ */
+export type ModelPath = Branded<string, 'ModelPath'>
+
+/**
+ * ModelFullPath is a type that represents the full path of a model.
+ * A model full path is a fully qualified path to a model.
+ */
+export type ModelFullPath = Branded<string, 'ModelFullPath'>

{sqlmesh-0.196.4.dev4 → sqlmesh-0.196.4.dev6}/vscode/react/src/domain/sqlmesh-model.ts

@@ -8,12 +8,24 @@ import {
   type ModelDefaultCatalog,
   type ModelDefinition,
 } from '@/api/client'
+import type {
+  ModelEncodedFQN,
+  ModelName,
+  ModelPath,
+  ModelEncodedName,
+  ModelFullPath,
+} from '@/domain/models'
 import { isArrayNotEmpty } from '@/utils/index'
 import { ModelInitial } from './initial'
 import type { Lineage } from './lineage'
 
-export interface InitialSQLMeshModel extends Model {
-  lineage?: Record<string, Lineage>
+export interface InitialSQLMeshModel
+  extends Omit<Model, 'name' | 'fqn' | 'path' | 'full_path'> {
+  name: ModelName
+  fqn: ModelEncodedFQN
+  path: ModelPath
+  full_path: ModelFullPath
+  lineage?: Record<ModelName, Lineage>
 }
 
 export class ModelSQLMeshModel<
@@ -22,9 +34,10 @@ export class ModelSQLMeshModel<
   _details: ModelDetails = {}
   _detailsIndex: string = ''
 
-  name: string
-  fqn: string
-  path: string
+  name: ModelEncodedName
+  fqn: ModelEncodedFQN
+  path: ModelPath
+  full_path: ModelFullPath
   dialect: string
   type: ModelType
   columns: Column[]
@@ -46,10 +59,11 @@ export class ModelSQLMeshModel<
           },
     )
 
-    this.name = encodeURI(this.initial.name)
-    this.fqn = encodeURI(this.initial.fqn)
+    this.name = encodeURI(this.initial.name) as ModelEncodedName
+    this.fqn = encodeURI(this.initial.fqn) as ModelEncodedFQN
     this.default_catalog = this.initial.default_catalog
-    this.path = this.initial.path
+    this.path = this.initial.path as ModelPath
+    this.full_path = this.initial.full_path as ModelFullPath
     this.dialect = this.initial.dialect
     this.description = this.initial.description
     this.sql = this.initial.sql
@@ -127,17 +141,21 @@ export class ModelSQLMeshModel<
       } else if (key === 'details') {
         this.details = value as ModelDetails
       } else if (key === 'name') {
-        this.name = encodeURI(value as string)
+        this.name = encodeURI(value as string) as ModelEncodedName
       } else if (key === 'fqn') {
-        this.fqn = encodeURI(value as string)
+        this.fqn = encodeURI(value as string) as ModelEncodedFQN
       } else if (key === 'type') {
         this.type = value as ModelType
       } else if (key === 'default_catalog') {
         this.default_catalog = value as ModelDefaultCatalog
       } else if (key === 'description') {
         this.description = value as ModelDescription
+      } else if (key === 'full_path') {
+        this.full_path = value as ModelFullPath
+      } else if (key === 'path') {
+        this.path = value as ModelPath
       } else if (key in this) {
-        this[key as 'path' | 'dialect' | 'sql'] = value as string
+        this[key as 'dialect' | 'sql'] = value as string
       }
     }
   }

{sqlmesh-0.196.4.dev4 → sqlmesh-0.196.4.dev6}/vscode/react/src/pages/lineage.tsx

@@ -16,6 +16,12 @@ import type { VSCodeEvent } from '@bus/callbacks'
 import { URI } from 'vscode-uri'
 import type { Model } from '@/api/client'
 import { useRpc } from '@/utils/rpc'
+import type {
+  ModelEncodedFQN,
+  ModelName,
+  ModelPath,
+  ModelFullPath,
+} from '@/domain/models'
 
 export function LineagePage() {
   const { emit } = useEventBus()
@@ -198,7 +204,13 @@ export function LineageComponentFromWeb({
   }
 
   const sqlmModel = new ModelSQLMeshModel()
-  sqlmModel.update(model)
+  sqlmModel.update({
+    ...model,
+    name: model.name as ModelName,
+    fqn: model.fqn as ModelEncodedFQN,
+    path: model.path as ModelPath,
+    full_path: model.full_path as ModelFullPath,
+  })
 
   return (
     <div className="h-[100vh] w-[100vw]">

{sqlmesh-0.196.4.dev4 → sqlmesh-0.196.4.dev6}/vscode/react/src/workers/lineage.ts

@@ -1,5 +1,6 @@
 import { isFalse, isNil, isStringEmptyOrNil, toID } from '@/utils/index'
 import { type Lineage } from '@/domain/lineage'
+import type { ModelEncodedFQN } from '@/domain/models'
 
 export interface ConnectedNode {
   id?: string
@@ -47,7 +48,7 @@ async function mergeLineageWithModels(
       key = encodeURI(key)
 
       acc[key] = {
-        models: models.map(encodeURI),
+        models: models.map(encodeURI) as ModelEncodedFQN[],
         columns: currentLineage?.[key]?.columns ?? undefined,
       }
 
@@ -88,7 +89,7 @@ function getConnectedNodes(
 
   if (isDownstream) {
     models = Object.keys(lineage).filter(key =>
-      lineage[key]!.models.includes(node),
+      lineage[key]!.models.includes(node as ModelEncodedFQN),
     )
   } else {
     models = lineage[node]?.models ?? []