feat: [#1670] Compile / Execute dbt Model (Full Refresh)

package.json

@@ -612,6 +612,11 @@
           "dark": "./media/images/build_dark.svg"
         }
       },
+      {
+        "command": "dbtPowerUser.compileCurrentModelFullRefresh",
+        "title": "Compile dbt Model (Full Refresh)",
+        "category": "dbt Power User"
+      },
       {
         "command": "dbtPowerUser.sqlPreview",
         "title": "Compiled dbt Preview",
@@ -719,6 +724,11 @@
         "category": "dbt Power User",
         "icon": "$(play)"
       },
+      {
+        "command": "dbtPowerUser.executeSQLFullRefresh",
+        "title": "Execute dbt SQL (Full Refresh)",
+        "category": "dbt Power User"
+      },
       {
         "command": "dbtPowerUser.buildCurrentModel",
         "title": "Build dbt Model",

src/commands/index.ts

@@ -289,6 +289,10 @@ export class VSCodeCommands implements Disposable {
       commands.registerCommand("dbtPowerUser.compileCurrentModel", () =>
         this.runModel.compileModelOnActiveWindow(),
       ),
+      commands.registerCommand(
+        "dbtPowerUser.compileCurrentModelFullRefresh",
+        () => this.runModel.compileModelOnActiveWindow(true),
+      ),
       commands.registerCommand(
         "dbtPowerUser.bigqueryCostEstimate",
         ({ returnResult }: { returnResult?: boolean }) =>
@@ -376,6 +380,9 @@ export class VSCodeCommands implements Disposable {
       commands.registerCommand("dbtPowerUser.executeSQL", () =>
         this.runModel.executeQueryOnActiveWindow(),
       ),
+      commands.registerCommand("dbtPowerUser.executeSQLFullRefresh", () =>
+        this.runModel.executeQueryOnActiveWindow(true),
+      ),
       commands.registerCommand(
         "dbtPowerUser.runSelectedQuery",
         (uri: Uri, range: Range) => this.runSelectedQuery(uri, range),

src/commands/runModel.ts

@@ -33,12 +33,12 @@ export class RunModel {
     this.runDBTModelTest(fullPath);
   }
 
-  compileModelOnActiveWindow() {
+  compileModelOnActiveWindow(fullRefresh: boolean = false) {
     if (!window.activeTextEditor) {
       return;
     }
     const fullPath = window.activeTextEditor.document.uri;
-    this.compileDBTModel(fullPath);
+    this.compileDBTModel(fullPath, undefined, fullRefresh);
   }
 
   compileQueryOnActiveWindow() {
@@ -62,15 +62,20 @@ export class RunModel {
     );
   }
 
-  executeQueryOnActiveWindow() {
+  executeQueryOnActiveWindow(fullRefresh: boolean = false) {
     const query = this.getQuery();
     if (query === undefined) {
       return;
     }
     const modelPath = window.activeTextEditor?.document.uri;
     if (modelPath) {
       const modelName = path.basename(modelPath.fsPath, ".sql");
-      this.executeSQL(window.activeTextEditor!.document.uri, query, modelName);
+      this.executeSQL(
+        window.activeTextEditor!.document.uri,
+        query,
+        modelName,
+        fullRefresh,
+      );
     }
   }
 
@@ -144,8 +149,12 @@ export class RunModel {
     this.dbtProjectContainer.buildModel(modelPath, type);
   }
 
-  compileDBTModel(modelPath: Uri, type?: RunModelType) {
-    this.dbtProjectContainer.compileModel(modelPath, type);
+  compileDBTModel(
+    modelPath: Uri,
+    type?: RunModelType,
+    fullRefresh: boolean = false,
+  ) {
+    this.dbtProjectContainer.compileModel(modelPath, type, fullRefresh);
   }
 
   generateDBTDocs(modelPath: Uri, type?: RunModelType) {
@@ -165,8 +174,13 @@ export class RunModel {
     this.dbtProjectContainer.runModelTest(modelPath, modelName);
   }
 
-  async executeSQL(uri: Uri, query: string, modelName: string) {
-    this.dbtProjectContainer.executeSQL(uri, query, modelName);
+  async executeSQL(
+    uri: Uri,
+    query: string,
+    modelName: string,
+    fullRefresh: boolean = false,
+  ) {
+    this.dbtProjectContainer.executeSQL(uri, query, modelName, fullRefresh);
   }
 
   showCompiledSQL(modelPath: Uri) {

src/dbt_client/dbtProject.ts

@@ -1320,17 +1320,27 @@ export class DBTProject implements Disposable {
     );
   }
 
-  async executeSQLOnQueryPanel(query: string, modelName: string) {
+  async executeSQLOnQueryPanel(
+    query: string,
+    modelName: string,
+    fullRefresh: boolean = false,
+  ) {
     const limit = workspace
       .getConfiguration("dbt")
       .get<number>("queryLimit", 500);
-    return this.executeSQLWithLimitOnQueryPanel(query, modelName, limit);
+    return this.executeSQLWithLimitOnQueryPanel(
+      query,
+      modelName,
+      limit,
+      fullRefresh,
+    );
   }
 
   async executeSQLWithLimitOnQueryPanel(
     query: string,
     modelName: string,
     limit: number,
+    fullRefresh: boolean = false,
   ) {
     if (limit <= 0) {
       window.showErrorMessage("Please enter a positive number for query limit");
@@ -1339,16 +1349,27 @@ export class DBTProject implements Disposable {
     this.terminal.info("executeSQL", "Executed query: " + query, true, {
       adapter: this.getAdapterType(),
       limit: limit.toString(),
+      fullRefresh: fullRefresh.toString(),
     });
+    // TODO(#1670): once `@altimateai/dbt-integration` is bumped to the version
+    // containing the `fullRefresh` plumbing
+    // (https://github.com/AltimateAI/altimate-dbt-integration/pull/44), drop
+    // the `as unknown as` cast — the published 0.2.12 types still declare
+    // `executeSQLWithLimit` with 3 params, so we widen locally here to let CI
+    // compile against the npm-published typings while the patched runtime
+    // accepts the 4th argument.
+    const executeSQLWithLimit = this.dbtProjectIntegration
+      .executeSQLWithLimit as unknown as (
+      query: string,
+      modelName: string,
+      limit: number,
+      fullRefresh?: boolean,
+    ) => Promise<QueryExecution>;
     this.eventEmitterService.fire({
       command: "executeQuery",
       payload: {
         query,
-        fn: this.dbtProjectIntegration.executeSQLWithLimit(
-          query,
-          modelName,
-          limit,
-        ),
+        fn: executeSQLWithLimit(query, modelName, limit, fullRefresh),
         projectName: this.getProjectName(),
       },
     });

src/dbt_client/dbtProjectContainer.ts

@@ -239,7 +239,12 @@ export class DBTProjectContainer implements Disposable {
     this.getProjects().forEach((project) => project.initialize());
   }
 
-  executeSQL(uri: Uri, query: string, modelName: string): void {
+  executeSQL(
+    uri: Uri,
+    query: string,
+    modelName: string,
+    fullRefresh: boolean = false,
+  ): void {
     if (uri.scheme === "untitled") {
       const selectedProject = this.getFromWorkspaceState(
         "dbtPowerUser.projectSelected",
@@ -248,7 +253,11 @@ export class DBTProjectContainer implements Disposable {
         uri = selectedProject.uri;
       }
     }
-    this.findDBTProject(uri)?.executeSQLOnQueryPanel(query, modelName);
+    this.findDBTProject(uri)?.executeSQLOnQueryPanel(
+      query,
+      modelName,
+      fullRefresh,
+    );
   }
 
   runModel(modelPath: Uri, type?: RunModelType) {
@@ -283,9 +292,13 @@ export class DBTProjectContainer implements Disposable {
     });
   }
 
-  compileModel(modelPath: Uri, type?: RunModelType) {
+  compileModel(
+    modelPath: Uri,
+    type?: RunModelType,
+    fullRefresh: boolean = false,
+  ) {
     this.findDBTProject(modelPath)?.compileModel(
-      this.createModelParams(modelPath, type),
+      this.createModelParams(modelPath, type, fullRefresh),
     );
   }
 
@@ -415,7 +428,11 @@ export class DBTProjectContainer implements Disposable {
     }
   }
 
-  private createModelParams(modelPath: Uri, type?: RunModelType) {
+  private createModelParams(
+    modelPath: Uri,
+    type?: RunModelType,
+    fullRefresh: boolean = false,
+  ) {
     const modelName = basename(
       fs.realpathSync.native(modelPath.fsPath),
       ".sql",
@@ -432,7 +449,7 @@ export class DBTProjectContainer implements Disposable {
       type === RunModelType.BUILD_CHILDREN_PARENTS
         ? "+"
         : "";
-    return { plusOperatorLeft, modelName, plusOperatorRight };
+    return { plusOperatorLeft, modelName, plusOperatorRight, fullRefresh };
   }
 
   private async registerWorkspaceFolder(

src/test/suite/runModelFullRefresh.test.ts

@@ -0,0 +1,120 @@
+import { beforeEach, describe, expect, it, jest } from "@jest/globals";
+import { Uri, window } from "vscode";
+import { RunModel } from "../../commands/runModel";
+import { DBTProjectContainer } from "../../dbt_client/dbtProjectContainer";
+
+/**
+ * Regression tests for AltimateAI/vscode-dbt-power-user#1670.
+ *
+ * `RunModel.compileModelOnActiveWindow` and `executeQueryOnActiveWindow`
+ * both gained an optional `fullRefresh` parameter. When true, the flag is
+ * threaded down through `DBTProjectContainer.compileModel` / `executeSQL`
+ * into `altimate-dbt-integration`, which either appends `--full-refresh`
+ * to the CLI compile args or sets `node.config.full_refresh = True` on
+ * the cloned node in the Python bridge. Downstream, dbt's
+ * `should_full_refresh()` macro returns true and `is_incremental()`
+ * returns false so users can preview the full-refresh shape of the
+ * compiled SQL without dropping the warehouse relation.
+ */
+describe("RunModel — fullRefresh dispatch (#1670)", () => {
+  let mockContainer: jest.Mocked<DBTProjectContainer>;
+  let runModel: RunModel;
+
+  const modelPath = "/workspace/jaffle/models/orders_incremental.sql";
+
+  const setActiveEditor = (fsPath: string | null) => {
+    Object.defineProperty(window, "activeTextEditor", {
+      value:
+        fsPath === null
+          ? undefined
+          : {
+              document: {
+                uri: Uri.file(fsPath),
+                getText: () => "select * from {{ ref('stg_orders') }}",
+              },
+              selection: { isEmpty: true },
+            },
+      writable: true,
+      configurable: true,
+    });
+  };
+
+  beforeEach(() => {
+    mockContainer = {
+      compileModel: jest.fn(),
+      executeSQL: jest.fn(),
+    } as unknown as jest.Mocked<DBTProjectContainer>;
+
+    runModel = new RunModel(mockContainer);
+  });
+
+  describe("compileModelOnActiveWindow", () => {
+    it("passes fullRefresh=false by default (existing behavior)", () => {
+      setActiveEditor(modelPath);
+
+      runModel.compileModelOnActiveWindow();
+
+      expect(mockContainer.compileModel).toHaveBeenCalledWith(
+        expect.anything(),
+        undefined,
+        false,
+      );
+    });
+
+    it("passes fullRefresh=true when the full-refresh variant is invoked (#1670)", () => {
+      setActiveEditor(modelPath);
+
+      runModel.compileModelOnActiveWindow(true);
+
+      expect(mockContainer.compileModel).toHaveBeenCalledWith(
+        expect.anything(),
+        undefined,
+        true,
+      );
+    });
+
+    it("no-ops when there is no active editor", () => {
+      setActiveEditor(null);
+
+      runModel.compileModelOnActiveWindow(true);
+
+      expect(mockContainer.compileModel).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("executeQueryOnActiveWindow", () => {
+    it("passes fullRefresh=false by default (existing Ctrl+Enter behavior)", () => {
+      setActiveEditor(modelPath);
+
+      runModel.executeQueryOnActiveWindow();
+
+      expect(mockContainer.executeSQL).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.any(String),
+        expect.any(String),
+        false,
+      );
+    });
+
+    it("passes fullRefresh=true when the full-refresh variant is invoked (#1670)", () => {
+      setActiveEditor(modelPath);
+
+      runModel.executeQueryOnActiveWindow(true);
+
+      expect(mockContainer.executeSQL).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.any(String),
+        expect.any(String),
+        true,
+      );
+    });
+
+    it("no-ops when there is no active editor", () => {
+      setActiveEditor(null);
+
+      runModel.executeQueryOnActiveWindow(true);
+
+      expect(mockContainer.executeSQL).not.toHaveBeenCalled();
+    });
+  });
+});