@vertesia/workflow 1.2.0 → 1.4.0-dev.20260615.042549Z

package/src/activities/media/saveGladiaTranscription.test.ts

@@ -1,14 +1,14 @@
-import { MockActivityEnvironment } from "@temporalio/testing";
-import { ContentEventName, DSLActivityExecutionPayload } from "@vertesia/common";
-import type { VertesiaClient } from "@vertesia/client";
-import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import type { ActivityContext, TextExtractionResult } from "@vertesia/workflow";
-import { TextExtractionStatus } from "../../result-types.js";
-import { saveGladiaTranscription, SaveGladiaTranscriptionParams } from "./saveGladiaTranscription.js";
+import { MockActivityEnvironment } from '@temporalio/testing';
+import type { VertesiaClient } from '@vertesia/client';
+import { ContentEventName, type DSLActivityExecutionPayload } from '@vertesia/common';
+import type { ActivityContext, TextExtractionResult } from '@vertesia/workflow';
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { TextExtractionStatus } from '../../result-types.js';
+import { type SaveGladiaTranscriptionParams, saveGladiaTranscription } from './saveGladiaTranscription.js';
 
 // Mock setupActivity from the relative path used by the activity
-vi.mock("../../dsl/setup/ActivityContext.js", async (importOriginal) => {
-    const actual = await importOriginal<typeof import("../../dsl/setup/ActivityContext.js")>();
+vi.mock('../../dsl/setup/ActivityContext.js', async (importOriginal) => {
+    const actual = await importOriginal<typeof import('../../dsl/setup/ActivityContext.js')>();
     return {
         ...actual,
         setupActivity: vi.fn(),
@@ -16,8 +16,8 @@ vi.mock("../../dsl/setup/ActivityContext.js", async (importOriginal) => {
 });
 
 // Mock FetchClient as a constructor
-vi.mock("@vertesia/api-fetch-client", async (importOriginal) => {
-    const actual = await importOriginal<typeof import("@vertesia/api-fetch-client")>();
+vi.mock('@vertesia/api-fetch-client', async (importOriginal) => {
+    const actual = await importOriginal<typeof import('@vertesia/api-fetch-client')>();
     return {
         ...actual,
         FetchClient: vi.fn(),
@@ -38,34 +38,36 @@ beforeEach(() => {
 const createTestPayload = (
     params: SaveGladiaTranscriptionParams,
     objectId?: string,
-    fileInput?: { url: string; mimetype: string }
+    fileInput?: { url: string; mimetype: string },
 ): DSLActivityExecutionPayload<SaveGladiaTranscriptionParams> => {
     return {
-        auth_token: process.env.VERTESIA_KEY || "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwOi8vbW9jay10b2tlbi1zZXJ2ZXIiLCJzdWIiOiJ0ZXN0In0.signature",
-        account_id: "test-account",
-        project_id: "test-project",
+        auth_token:
+            process.env.VERTESIA_KEY ||
+            'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwOi8vbW9jay10b2tlbi1zZXJ2ZXIiLCJzdWIiOiJ0ZXN0In0.signature',
+        account_id: 'test-account',
+        project_id: 'test-project',
         params,
         config: {
-            studio_url: "http://mock-studio",
-            store_url: "http://mock-store",
+            studio_url: 'http://mock-studio',
+            store_url: 'http://mock-store',
         },
-        workflow_name: "test-workflow",
+        workflow_name: 'test-workflow',
         event: ContentEventName.create,
         objectIds: objectId ? [objectId] : [],
         input: fileInput
             ? { inputType: 'files' as const, files: [fileInput] }
             : objectId
-            ? { inputType: 'objectIds' as const, objectIds: [objectId] }
-            : undefined,
+              ? { inputType: 'objectIds' as const, objectIds: [objectId] }
+              : undefined,
         vars: {},
-        activity: { name: "SaveGladiaTranscription", params }
+        activity: { name: 'SaveGladiaTranscription', params: params as unknown as Record<string, unknown> },
     };
 };
 
 // Mock Gladia transcription response
 const mockGladiaTranscriptionResult = {
-    id: "test-transcription-id",
-    status: "done" as const,
+    id: 'test-transcription-id',
+    status: 'done' as const,
     result: {
         metadata: {
             audio_duration: 120.5,
@@ -74,44 +76,44 @@ const mockGladiaTranscriptionResult = {
             transcription_time: 30,
         },
         transcription: {
-            full_transcript: "Hello world, this is a test transcription.",
-            languages: ["en"],
+            full_transcript: 'Hello world, this is a test transcription.',
+            languages: ['en'],
             utterances: [
                 {
-                    language: "en",
+                    language: 'en',
                     start: 0,
                     end: 2.5,
                     confidence: 0.95,
                     channel: 0,
                     speaker: 0,
-                    text: "Hello world,"
+                    text: 'Hello world,',
                 },
                 {
-                    language: "en",
+                    language: 'en',
                     start: 2.5,
                     end: 5.0,
                     confidence: 0.97,
                     channel: 0,
                     speaker: 0,
-                    text: "this is a test transcription."
-                }
+                    text: 'this is a test transcription.',
+                },
             ],
         },
     },
 };
 
-describe("SaveGladiaTranscription", () => {
-    it("should save transcription in object mode", async () => {
-        const { setupActivity } = await import("../../dsl/setup/ActivityContext.js");
-        const { FetchClient } = await import("@vertesia/api-fetch-client");
+describe('SaveGladiaTranscription', () => {
+    it('should save transcription in object mode', async () => {
+        const { setupActivity } = await import('../../dsl/setup/ActivityContext.js');
+        const { FetchClient } = await import('@vertesia/api-fetch-client');
 
         // Mock FetchClient instance
         const mockFetchClient = {
             withHeaders: vi.fn().mockReturnThis(),
             get: vi.fn().mockResolvedValue(mockGladiaTranscriptionResult),
         };
-        vi.mocked(FetchClient).mockImplementation(function(this: any) {
-            return mockFetchClient as any;
+        vi.mocked(FetchClient).mockImplementation(function (this: unknown) {
+            return mockFetchClient as unknown;
         });
 
         // Mock client
@@ -120,52 +122,52 @@ describe("SaveGladiaTranscription", () => {
                 integrations: {
                     retrieve: vi.fn().mockResolvedValue({
                         enabled: true,
-                        api_key: "test-api-key",
-                        url: "https://api.gladia.io/v2",
+                        api_key: 'test-api-key',
+                        url: 'https://api.gladia.io/v2',
                     }),
                 },
             },
             objects: {
                 retrieve: vi.fn().mockResolvedValue({
-                    content: { etag: "test-etag" },
+                    content: { etag: 'test-etag' },
                 }),
                 update: vi.fn().mockResolvedValue({}),
             },
         } as unknown as VertesiaClient;
 
-        const params: SaveGladiaTranscriptionParams = {
-            gladiaTranscriptionId: "test-transcription-id",
-        };
+        const params = {
+            gladiaTranscriptionId: 'test-transcription-id',
+        } satisfies SaveGladiaTranscriptionParams;
 
         // Mock setupActivity
         vi.mocked(setupActivity).mockResolvedValue({
             client: mockClient,
-            objectId: "test-object-id",
+            objectId: 'test-object-id',
             inputType: 'objectIds',
             params,
         } as unknown as ActivityContext<SaveGladiaTranscriptionParams>);
 
-        const payload = createTestPayload(params, "test-object-id");
+        const payload = createTestPayload(params, 'test-object-id');
         const result: TextExtractionResult = await testEnv.run(saveGladiaTranscription, payload);
 
         expect(result).toMatchObject({
             hasText: true,
-            objectId: "test-object-id",
+            objectId: 'test-object-id',
             status: TextExtractionStatus.success,
         });
-        expect(result.message).toContain("saved with 2 segments");
+        expect(result.message).toContain('saved with 2 segments');
     });
 
-    it("should handle transcription in file mode", async () => {
-        const { setupActivity } = await import("../../dsl/setup/ActivityContext.js");
-        const { FetchClient } = await import("@vertesia/api-fetch-client");
+    it('should handle transcription in file mode', async () => {
+        const { setupActivity } = await import('../../dsl/setup/ActivityContext.js');
+        const { FetchClient } = await import('@vertesia/api-fetch-client');
 
         const mockFetchClient = {
             withHeaders: vi.fn().mockReturnThis(),
             get: vi.fn().mockResolvedValue(mockGladiaTranscriptionResult),
         };
-        vi.mocked(FetchClient).mockImplementation(function(this: any) {
-            return mockFetchClient as any;
+        vi.mocked(FetchClient).mockImplementation(function (this: unknown) {
+            return mockFetchClient as unknown;
         });
 
         const mockClient = {
@@ -173,8 +175,8 @@ describe("SaveGladiaTranscription", () => {
                 integrations: {
                     retrieve: vi.fn().mockResolvedValue({
                         enabled: true,
-                        api_key: "test-api-key",
-                        url: "https://api.gladia.io/v2",
+                        api_key: 'test-api-key',
+                        url: 'https://api.gladia.io/v2',
                     }),
                 },
             },
@@ -183,35 +185,34 @@ describe("SaveGladiaTranscription", () => {
             },
         } as unknown as VertesiaClient;
 
-        const params: SaveGladiaTranscriptionParams = {
-            gladiaTranscriptionId: "test-transcription-id",
-            output_storage_path: "test-storage-path",
-        };
+        const params = {
+            gladiaTranscriptionId: 'test-transcription-id',
+            output_storage_path: 'test-storage-path',
+        } satisfies SaveGladiaTranscriptionParams;
 
         vi.mocked(setupActivity).mockResolvedValue({
             client: mockClient,
-            file: { url: "gs://test-bucket/audio.mp3", mimetype: "audio/mpeg" },
+            file: { url: 'gs://test-bucket/audio.mp3', mimetype: 'audio/mpeg' },
             inputType: 'files',
             params,
         } as unknown as ActivityContext<SaveGladiaTranscriptionParams>);
 
-        const payload = createTestPayload(
-            params,
-            undefined,
-            { url: "gs://test-bucket/audio.mp3", mimetype: "audio/mpeg" }
-        );
+        const payload = createTestPayload(params, undefined, {
+            url: 'gs://test-bucket/audio.mp3',
+            mimetype: 'audio/mpeg',
+        });
         const result: TextExtractionResult = await testEnv.run(saveGladiaTranscription, payload);
 
         expect(result).toMatchObject({
             hasText: true,
-            objectId: "test-storage-path",
+            objectId: 'test-storage-path',
             status: TextExtractionStatus.success,
         });
-        expect(result.message).toContain("completed with 2 segments");
+        expect(result.message).toContain('completed with 2 segments');
     });
 
-    it("should handle Gladia integration not enabled", async () => {
-        const { setupActivity } = await import("../../dsl/setup/ActivityContext.js");
+    it('should handle Gladia integration not enabled', async () => {
+        const { setupActivity } = await import('../../dsl/setup/ActivityContext.js');
 
         const mockClient = {
             projects: {
@@ -223,41 +224,41 @@ describe("SaveGladiaTranscription", () => {
             },
         } as unknown as VertesiaClient;
 
-        const params: SaveGladiaTranscriptionParams = {
-            gladiaTranscriptionId: "test-transcription-id",
-        };
+        const params = {
+            gladiaTranscriptionId: 'test-transcription-id',
+        } satisfies SaveGladiaTranscriptionParams;
 
         vi.mocked(setupActivity).mockResolvedValue({
             client: mockClient,
-            objectId: "test-object-id",
+            objectId: 'test-object-id',
             inputType: 'objectIds',
             params,
         } as unknown as ActivityContext<SaveGladiaTranscriptionParams>);
 
-        const payload = createTestPayload(params, "test-object-id");
+        const payload = createTestPayload(params, 'test-object-id');
         const result: TextExtractionResult = await testEnv.run(saveGladiaTranscription, payload);
 
         expect(result).toMatchObject({
             hasText: false,
-            objectId: "test-object-id",
+            objectId: 'test-object-id',
             status: TextExtractionStatus.error,
-            error: "Gladia integration not enabled",
+            error: 'Gladia integration not enabled',
         });
     });
 
-    it("should handle Gladia transcription error status", async () => {
-        const { setupActivity } = await import("../../dsl/setup/ActivityContext.js");
-        const { FetchClient } = await import("@vertesia/api-fetch-client");
+    it('should handle Gladia transcription error status', async () => {
+        const { setupActivity } = await import('../../dsl/setup/ActivityContext.js');
+        const { FetchClient } = await import('@vertesia/api-fetch-client');
 
         const mockFetchClient = {
             withHeaders: vi.fn().mockReturnThis(),
             get: vi.fn().mockResolvedValue({
-                id: "test-transcription-id",
-                status: "error",
+                id: 'test-transcription-id',
+                status: 'error',
             }),
         };
-        vi.mocked(FetchClient).mockImplementation(function(this: any) {
-            return mockFetchClient as any;
+        vi.mocked(FetchClient).mockImplementation(function (this: unknown) {
+            return mockFetchClient as unknown;
         });
 
         const mockClient = {
@@ -265,48 +266,48 @@ describe("SaveGladiaTranscription", () => {
                 integrations: {
                     retrieve: vi.fn().mockResolvedValue({
                         enabled: true,
-                        api_key: "test-api-key",
-                        url: "https://api.gladia.io/v2",
+                        api_key: 'test-api-key',
+                        url: 'https://api.gladia.io/v2',
                     }),
                 },
             },
         } as unknown as VertesiaClient;
 
-        const params: SaveGladiaTranscriptionParams = {
-            gladiaTranscriptionId: "test-transcription-id",
-        };
+        const params = {
+            gladiaTranscriptionId: 'test-transcription-id',
+        } satisfies SaveGladiaTranscriptionParams;
 
         vi.mocked(setupActivity).mockResolvedValue({
             client: mockClient,
-            objectId: "test-object-id",
+            objectId: 'test-object-id',
             inputType: 'objectIds',
             params,
         } as unknown as ActivityContext<SaveGladiaTranscriptionParams>);
 
-        const payload = createTestPayload(params, "test-object-id");
+        const payload = createTestPayload(params, 'test-object-id');
         const result: TextExtractionResult = await testEnv.run(saveGladiaTranscription, payload);
 
         expect(result).toMatchObject({
             hasText: false,
-            objectId: "test-object-id",
+            objectId: 'test-object-id',
             status: TextExtractionStatus.error,
-            error: "Gladia transcription failed",
+            error: 'Gladia transcription failed',
         });
     });
 
-    it("should handle Gladia transcription not ready", async () => {
-        const { setupActivity } = await import("../../dsl/setup/ActivityContext.js");
-        const { FetchClient } = await import("@vertesia/api-fetch-client");
+    it('should handle Gladia transcription not ready', async () => {
+        const { setupActivity } = await import('../../dsl/setup/ActivityContext.js');
+        const { FetchClient } = await import('@vertesia/api-fetch-client');
 
         const mockFetchClient = {
             withHeaders: vi.fn().mockReturnThis(),
             get: vi.fn().mockResolvedValue({
-                id: "test-transcription-id",
-                status: "processing",
+                id: 'test-transcription-id',
+                status: 'processing',
             }),
         };
-        vi.mocked(FetchClient).mockImplementation(function(this: any) {
-            return mockFetchClient as any;
+        vi.mocked(FetchClient).mockImplementation(function (this: unknown) {
+            return mockFetchClient as unknown;
         });
 
         const mockClient = {
@@ -314,38 +315,38 @@ describe("SaveGladiaTranscription", () => {
                 integrations: {
                     retrieve: vi.fn().mockResolvedValue({
                         enabled: true,
-                        api_key: "test-api-key",
-                        url: "https://api.gladia.io/v2",
+                        api_key: 'test-api-key',
+                        url: 'https://api.gladia.io/v2',
                     }),
                 },
             },
         } as unknown as VertesiaClient;
 
-        const params: SaveGladiaTranscriptionParams = {
-            gladiaTranscriptionId: "test-transcription-id",
-        };
+        const params = {
+            gladiaTranscriptionId: 'test-transcription-id',
+        } satisfies SaveGladiaTranscriptionParams;
 
         vi.mocked(setupActivity).mockResolvedValue({
             client: mockClient,
-            objectId: "test-object-id",
+            objectId: 'test-object-id',
             inputType: 'objectIds',
             params,
         } as unknown as ActivityContext<SaveGladiaTranscriptionParams>);
 
-        const payload = createTestPayload(params, "test-object-id");
+        const payload = createTestPayload(params, 'test-object-id');
         const result: TextExtractionResult = await testEnv.run(saveGladiaTranscription, payload);
 
         expect(result).toMatchObject({
             hasText: false,
-            objectId: "test-object-id",
+            objectId: 'test-object-id',
             status: TextExtractionStatus.error,
         });
-        expect(result.error).toContain("not ready: processing");
+        expect(result.error).toContain('not ready: processing');
     });
 
-    it("should handle empty transcript", async () => {
-        const { setupActivity } = await import("../../dsl/setup/ActivityContext.js");
-        const { FetchClient } = await import("@vertesia/api-fetch-client");
+    it('should handle empty transcript', async () => {
+        const { setupActivity } = await import('../../dsl/setup/ActivityContext.js');
+        const { FetchClient } = await import('@vertesia/api-fetch-client');
 
         const mockFetchClient = {
             withHeaders: vi.fn().mockReturnThis(),
@@ -354,15 +355,15 @@ describe("SaveGladiaTranscription", () => {
                 result: {
                     ...mockGladiaTranscriptionResult.result,
                     transcription: {
-                        full_transcript: "",
+                        full_transcript: '',
                         languages: [],
                         utterances: [],
                     },
                 },
             }),
         };
-        vi.mocked(FetchClient).mockImplementation(function(this: any) {
-            return mockFetchClient as any;
+        vi.mocked(FetchClient).mockImplementation(function (this: unknown) {
+            return mockFetchClient as unknown;
         });
 
         const mockClient = {
@@ -370,36 +371,36 @@ describe("SaveGladiaTranscription", () => {
                 integrations: {
                     retrieve: vi.fn().mockResolvedValue({
                         enabled: true,
-                        api_key: "test-api-key",
-                        url: "https://api.gladia.io/v2",
+                        api_key: 'test-api-key',
+                        url: 'https://api.gladia.io/v2',
                     }),
                 },
             },
             objects: {
                 retrieve: vi.fn().mockResolvedValue({
-                    content: { etag: "test-etag" },
+                    content: { etag: 'test-etag' },
                 }),
                 update: vi.fn().mockResolvedValue({}),
             },
         } as unknown as VertesiaClient;
 
-        const params: SaveGladiaTranscriptionParams = {
-            gladiaTranscriptionId: "test-transcription-id",
-        };
+        const params = {
+            gladiaTranscriptionId: 'test-transcription-id',
+        } satisfies SaveGladiaTranscriptionParams;
 
         vi.mocked(setupActivity).mockResolvedValue({
             client: mockClient,
-            objectId: "test-object-id",
+            objectId: 'test-object-id',
             inputType: 'objectIds',
             params,
         } as unknown as ActivityContext<SaveGladiaTranscriptionParams>);
 
-        const payload = createTestPayload(params, "test-object-id");
+        const payload = createTestPayload(params, 'test-object-id');
         const result: TextExtractionResult = await testEnv.run(saveGladiaTranscription, payload);
 
         expect(result).toMatchObject({
             hasText: false,
-            objectId: "test-object-id",
+            objectId: 'test-object-id',
             status: TextExtractionStatus.success,
         });
     });