@cognite/dune 0.3.7 → 0.4.1

package/src/deploy/apphosting-deployer.test.ts

@@ -0,0 +1,177 @@
+import { type CogniteClient, HttpError } from '@cognite/sdk';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { AppHostingDeployer } from './apphosting-deployer';
+
+vi.mock('node:fs', () => ({
+  default: {
+    readFileSync: vi.fn(() => Buffer.from('fake-zip-content')),
+  },
+}));
+
+vi.mock('node:path', () => ({
+  default: {
+    basename: vi.fn(() => 'app.zip'),
+  },
+}));
+
+const BASE_URL = 'https://cognite.test';
+const PROJECT = 'test-project';
+const TOKEN = 'test-token';
+
+function makeDeployer() {
+  const mockClient = {
+    project: PROJECT,
+    authenticate: vi.fn(() => Promise.resolve(TOKEN)),
+    getBaseUrl: vi.fn(() => BASE_URL),
+    post: vi.fn(),
+  };
+  const deployer = new AppHostingDeployer(
+    mockClient as Partial<CogniteClient> as CogniteClient,
+  );
+  return { deployer, mockClient };
+}
+
+function mockFetchResponse(ok: boolean, status: number, body = '') {
+  return vi.fn(() =>
+    Promise.resolve({
+      ok,
+      status,
+      text: vi.fn(() => Promise.resolve(body)),
+    } as Partial<Response> as Response)
+  );
+}
+
+function makeHttpError(status: number, message = 'Error') {
+  return new HttpError(status, { error: { code: status, message } }, {});
+}
+
+describe(AppHostingDeployer.name, () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  describe('ensureApp', () => {
+    it('resolves when app already exists (409)', async () => {
+      const { deployer, mockClient } = makeDeployer();
+      mockClient.post.mockRejectedValueOnce(makeHttpError(409, 'Conflict'));
+
+      await expect(
+        deployer.ensureApp('my-app', 'My App', 'A description')
+      ).resolves.toBeUndefined();
+    });
+
+    it('throws on unexpected API error', async () => {
+      const { deployer, mockClient } = makeDeployer();
+      mockClient.post.mockRejectedValueOnce(makeHttpError(500, 'Internal Server Error'));
+
+      await expect(
+        deployer.ensureApp('my-app', 'My App', 'A description')
+      ).rejects.toThrow('Request failed | status code: 500');
+    });
+
+    it('sends POST to the apps endpoint with correct path and data', async () => {
+      const { deployer, mockClient } = makeDeployer();
+      mockClient.post.mockResolvedValueOnce({ data: {}, status: 201, headers: {} });
+
+      await deployer.ensureApp('my-app', 'My App', 'A description');
+
+      expect(mockClient.post).toHaveBeenCalledWith(
+        `/api/v1/projects/${PROJECT}/apphosting/apps`,
+        expect.objectContaining({
+          data: { items: [{ externalId: 'my-app', name: 'My App', description: 'A description' }] },
+        })
+      );
+    });
+  });
+
+  describe('uploadVersion', () => {
+    it('throws on upload failure', async () => {
+      const { deployer } = makeDeployer();
+      vi.stubGlobal('fetch', mockFetchResponse(false, 413, 'Payload Too Large'));
+
+      await expect(
+        deployer.uploadVersion('my-app', '1.0.0', '/tmp/app.zip')
+      ).rejects.toThrow('Upload failed: 413');
+    });
+
+    it('sends POST to the versions endpoint with auth header and form data', async () => {
+      const { deployer, mockClient } = makeDeployer();
+      const fetchMock = mockFetchResponse(true, 200);
+      vi.stubGlobal('fetch', fetchMock);
+
+      await deployer.uploadVersion('my-app', '1.0.0', '/tmp/app.zip');
+
+      expect(fetchMock).toHaveBeenCalledWith(
+        `${BASE_URL}/api/v1/projects/${PROJECT}/apphosting/apps/my-app/versions`,
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining({ Authorization: `Bearer ${TOKEN}` }),
+          body: expect.any(FormData),
+        })
+      );
+    });
+  });
+
+  describe('publishAndActivate', () => {
+    it('throws on publish failure', async () => {
+      const { deployer, mockClient } = makeDeployer();
+      mockClient.post.mockRejectedValueOnce(makeHttpError(400, 'Bad Request'));
+
+      await expect(
+        deployer.publishAndActivate('my-app', '1.0.0')
+      ).rejects.toThrow('Request failed | status code: 400');
+    });
+
+    it('sends POST to the versions/update endpoint', async () => {
+      const { deployer, mockClient } = makeDeployer();
+      mockClient.post.mockResolvedValueOnce({ data: {}, status: 200, headers: {} });
+
+      await deployer.publishAndActivate('my-app', '1.0.0');
+
+      expect(mockClient.post).toHaveBeenCalledWith(
+        `/api/v1/projects/${PROJECT}/apphosting/apps/my-app/versions/update`,
+        expect.any(Object)
+      );
+    });
+  });
+
+  describe('deploy', () => {
+    it('calls ensureApp and uploadVersion but not publishAndActivate when published is false', async () => {
+      const { deployer, mockClient } = makeDeployer();
+      mockClient.post.mockResolvedValue({ data: {}, status: 200, headers: {} });
+      vi.stubGlobal('fetch', mockFetchResponse(true, 200));
+
+      await deployer.deploy('my-app', 'My App', 'A description', '1.0.0', '/tmp/app.zip', false);
+
+      // ensureApp → 1 client.post, uploadVersion → 1 fetch, publishAndActivate → not called
+      expect(mockClient.post).toHaveBeenCalledTimes(1);
+      expect(global.fetch).toHaveBeenCalledTimes(1);
+    });
+
+    it('calls publishAndActivate as third step when published is true', async () => {
+      const { deployer, mockClient } = makeDeployer();
+      mockClient.post.mockResolvedValue({ data: {}, status: 200, headers: {} });
+      vi.stubGlobal('fetch', mockFetchResponse(true, 200));
+
+      await deployer.deploy('my-app', 'My App', 'A description', '1.0.0', '/tmp/app.zip', true);
+
+      // ensureApp + publishAndActivate → 2 client.post, uploadVersion → 1 fetch
+      expect(mockClient.post).toHaveBeenCalledTimes(2);
+      expect(global.fetch).toHaveBeenCalledTimes(1);
+    });
+
+    it('wraps errors with "Deployment failed:" prefix', async () => {
+      const { deployer, mockClient } = makeDeployer();
+      mockClient.post.mockRejectedValueOnce(makeHttpError(500, 'Server Error'));
+
+      await expect(
+        deployer.deploy('my-app', 'My App', 'A description', '1.0.0', '/tmp/app.zip')
+      ).rejects.toThrow('Deployment failed:');
+    });
+  });
+});

package/src/deploy/apphosting-deployer.ts

@@ -0,0 +1,166 @@
+/**
+ * App Hosting API Deployment
+ *
+ * Handles deployment of packaged applications via the new App Hosting API
+ * instead of CDF Files API + dataset.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { type CogniteClient } from '@cognite/sdk';
+
+export class AppHostingDeployer {
+  private client: CogniteClient;
+
+  constructor(client: CogniteClient) {
+    this.client = client;
+  }
+
+  private get appsBasePath(): string {
+    return `/api/v1/projects/${encodeURIComponent(this.client.project)}/apphosting/apps`;
+  }
+
+  /**
+   * Ensure the app exists in the App Hosting service. Creates it if missing.
+   */
+  async ensureApp(externalId: string, name: string, description: string): Promise<void> {
+    console.log('🔍 Ensuring app exists...');
+
+    try {
+      await this.client.post(this.appsBasePath, {
+        data: { items: [{ externalId, name, description }] },
+      });
+      console.log(`✅ App '${externalId}' created`);
+    } catch (error) {
+      if (error instanceof Error && 'status' in error && error.status === 409) {
+        console.log(`✅ App '${externalId}' already exists`);
+        return;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Upload a new version of the app as a zip file.
+   *
+   * `entryPath` must be a relative path (no leading slash). The App
+   * Hosting backend rejects absolute paths as a security measure against
+   * archive traversal, see `ZipCentralDirectory.normalizeEntryPath` in
+   * infrastructure/services/app-hosting.
+   */
+  async uploadVersion(
+    appExternalId: string,
+    version: string,
+    zipPath: string,
+    entryPath = 'index.html',
+  ): Promise<void> {
+    console.log(`📤 Uploading version ${version}...`);
+
+    const fileBuffer = fs.readFileSync(zipPath);
+    const fileName = path.basename(zipPath);
+
+    const formData = new FormData();
+    formData.append('file', new Blob([fileBuffer]), fileName);
+    formData.append('version', version);
+    formData.append('entryPath', entryPath);
+
+    const encodedAppExternalId = encodeURIComponent(appExternalId);
+    const uploadPath = `${this.appsBasePath}/${encodedAppExternalId}/versions`;
+
+    // client.post always sends application/json; use fetch directly so FormData
+    // sets the correct multipart/form-data Content-Type with boundary
+    const token = await this.client.authenticate();
+    const url = `${this.client.getBaseUrl()}${uploadPath}`;
+
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5 * 60 * 1000);
+
+    let response: Response;
+    try {
+      response = await fetch(url, {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${token}` },
+        body: formData,
+        signal: controller.signal,
+      });
+    } catch (error) {
+      if (error instanceof Error && error.name === 'AbortError') {
+        throw new Error('Upload timed out after 5 minutes');
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+    }
+
+    if (!response.ok) {
+      const body = await response.text();
+      let message = body;
+      try {
+        const json = JSON.parse(body) as { message?: string; error?: string };
+        message = json.message ?? json.error ?? body;
+      } catch {
+        // not JSON, use raw text
+      }
+      throw new Error(`Upload failed: ${response.status} — ${message}`);
+    }
+
+    console.log(`✅ Version ${version} uploaded`);
+  }
+
+  /**
+   * Publish the version and set it as the ACTIVE alias.
+   */
+  async publishAndActivate(appExternalId: string, version: string): Promise<void> {
+    console.log(`🚀 Publishing and activating version ${version}...`);
+
+    const encodedAppExternalId = encodeURIComponent(appExternalId);
+    const url = `${this.appsBasePath}/${encodedAppExternalId}/versions/update`;
+
+    await this.client.post(url, {
+      data: {
+        items: [
+          {
+            version,
+            update: {
+              lifecycleState: { set: 'PUBLISHED' },
+              alias: { set: 'ACTIVE' },
+            },
+          },
+        ],
+      },
+    });
+
+    console.log(`✅ Version ${version} is now PUBLISHED and ACTIVE`);
+  }
+
+  /**
+   * Full deployment: ensure app exists, upload version, and optionally publish and activate.
+   *
+   * When `published` is false the version is uploaded in DRAFT state with no alias —
+   * it is stored but not served to end users. Pass `published: true` to transition the
+   * version to PUBLISHED and set it as the ACTIVE alias so it starts receiving traffic.
+   */
+  async deploy(
+    appExternalId: string,
+    name: string,
+    description: string,
+    versionTag: string,
+    zipPath: string,
+    published = false,
+  ): Promise<void> {
+    console.log('\n🚀 Deploying application via App Hosting API...\n');
+
+    try {
+      await this.ensureApp(appExternalId, name, description);
+      await this.uploadVersion(appExternalId, versionTag, zipPath);
+      if (published) {
+        await this.publishAndActivate(appExternalId, versionTag);
+      }
+      console.log('\n✅ Deployment successful!');
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw Object.assign(new Error(`Deployment failed: ${message}`), { cause: error });
+    }
+  }
+}

package/src/deploy/deploy.ts

@@ -1,34 +1,39 @@
 import fs from 'node:fs';
 
+import { AppHostingDeployer } from './apphosting-deployer';
 import { CdfApplicationDeployer } from './application-deployer';
 import { ApplicationPackager } from './application-packager';
 import { getSdk } from './get-sdk';
 import type { App, Deployment } from './types';
 
-export const deploy = async (deployment: Deployment, app: App, folder: string) => {
-  // Step 1: Get an SDK instance
+async function deployViaAppHosting(deployment: Deployment, app: App, folder: string, zipFilename: string) {
+  const { externalId, name, description, versionTag } = app;
   const sdk = await getSdk(deployment, folder);
+  const deployer = new AppHostingDeployer(sdk);
+  await deployer.deploy(externalId, name, description, versionTag, zipFilename, deployment.published);
+}
 
-  // Step 2: Package application (from the dist subdirectory)
-  const distPath = `${folder}/dist`;
-  const packager = new ApplicationPackager(distPath);
-  const zipFilename = await packager.createZip('app.zip', true);
-
-  // Step 3: Deploy to CDF
+async function deployViaCdf(deployment: Deployment, app: App, folder: string, zipFilename: string) {
+  const { externalId, name, description, versionTag } = app;
+  const sdk = await getSdk(deployment, folder);
   const deployer = new CdfApplicationDeployer(sdk);
-  await deployer.deploy(
-    app.externalId,
-    app.name,
-    app.description,
-    app.versionTag,
-    zipFilename,
-    deployment.published
-  );
+  await deployer.deploy(externalId, name, description, versionTag, zipFilename, deployment.published);
+}
+
+export const deploy = async (deployment: Deployment, app: App, folder: string) => {
+  const zipFilename = await new ApplicationPackager(`${folder}/dist`).createZip('app.zip', true);
 
-  // Step 4: Clean up zip file
   try {
-    fs.unlinkSync(zipFilename);
-  } catch {
-    // Ignore cleanup errors
+    if (app.infra === 'appsApi') {
+      await deployViaAppHosting(deployment, app, folder, zipFilename);
+    } else {
+      await deployViaCdf(deployment, app, folder, zipFilename);
+    }
+  } finally {
+    try {
+      fs.unlinkSync(zipFilename);
+    } catch {
+      // Ignore cleanup errors
+    }
   }
 };

package/src/deploy/index.ts

@@ -1,5 +1,6 @@
 // Deploy exports for CI/CD and programmatic deployment
 export { deploy } from './deploy';
+export { AppHostingDeployer } from './apphosting-deployer';
 export { CdfApplicationDeployer } from './application-deployer';
 export { ApplicationPackager } from './application-packager';
 export { getSdk } from './get-sdk';

package/src/deploy/types.ts

@@ -16,4 +16,6 @@ export type App = {
   name: string;
   description: string;
   versionTag: string;
+  /** When set to "appsApi", deploy uses the App Hosting API instead of Files API */
+  infra?: "appsApi";
 };

package/src/vite/fusion-open-plugin.ts

@@ -37,7 +37,16 @@ export const fusionOpenPlugin = () => {
             const parsedBaseUrl = baseUrl?.split('//')[1];
 
             if (org && project && baseUrl) {
-              const fusionUrl = `https://${org}.fusion.cognite.com/${project}/streamlit-apps/dune/development/${port}?cluster=${parsedBaseUrl}&workspace=industrial-tools`;
+              let fusionUrl: string;
+              if (appJson.infra === 'appsApi') {
+                if (!appJson.externalId) {
+                  console.warn('  ➜  app.json is missing externalId — cannot determine Fusion URL');
+                  return;
+                }
+                fusionUrl = `https://${org}.fusion.cognite.com/${project}/dune-app-host/development/${appJson.externalId}/${port}?cluster=${parsedBaseUrl}`;
+              } else {
+                fusionUrl = `https://${org}.fusion.cognite.com/${project}/streamlit-apps/dune/development/${port}?cluster=${parsedBaseUrl}&workspace=industrial-tools`;
+              }
               console.log(`  ➜  Fusion: ${fusionUrl}`);
               openUrl(fusionUrl);
               return;