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

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

@@ -1,9 +1,9 @@
 import { MockActivityEnvironment } from '@temporalio/testing';
 import type { VertesiaClient } from '@vertesia/client';
-import { ContentEventName, DSLActivityExecutionPayload } from '@vertesia/common';
+import { ContentEventName, type DSLActivityExecutionPayload } from '@vertesia/common';
 import type { ActivityContext } from '@vertesia/workflow';
 import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
-import { probeMediaStreams, ProbeMediaStreamsParams, ProbeMediaStreamsResult } from './probeMediaStreams.js';
+import { type ProbeMediaStreamsParams, type ProbeMediaStreamsResult, probeMediaStreams } from './probeMediaStreams.js';
 
 vi.mock('../../dsl/setup/ActivityContext.js', async (importOriginal) => {
     const actual = await importOriginal<typeof import('../../dsl/setup/ActivityContext.js')>();
@@ -33,14 +33,14 @@ const createPayload = (objectId = 'test-object-id'): DSLActivityExecutionPayload
     auth_token: 'mock-token',
     account_id: 'test-account',
     project_id: 'test-project',
-    params: {},
+    params: {} satisfies ProbeMediaStreamsParams,
     config: { studio_url: 'http://mock-studio', store_url: 'http://mock-store' },
     workflow_name: 'test-workflow',
     event: ContentEventName.create,
     objectIds: [objectId],
     input: { inputType: 'objectIds', objectIds: [objectId] },
     vars: {},
-    activity: { name: 'probeMediaStreams', params: {} },
+    activity: { name: 'probeMediaStreams', params: {} satisfies ProbeMediaStreamsParams },
 });
 
 function mockExec(stdout: string) {
@@ -68,7 +68,7 @@ async function setupMockContext(objectId: string, signedUrl: string): Promise<vo
 }
 
 describe('probeMediaStreams', () => {
-    it('returns hasVideo=true and hasAudio=true for a video+audio container', async () => {
+    it('should return hasVideo=true and hasAudio=true for a video+audio container', async () => {
         await setupMockContext('test-object-id', 'https://storage.example.com/file.mp4?token=abc');
         mockExec(JSON.stringify({ streams: [{ codec_type: 'video' }, { codec_type: 'audio' }] }));
 
@@ -77,7 +77,7 @@ describe('probeMediaStreams', () => {
         expect(result).toEqual({ hasVideo: true, hasAudio: true });
     });
 
-    it('returns hasVideo=true and hasAudio=false for a video-only container', async () => {
+    it('should return hasVideo=true and hasAudio=false for a video-only container', async () => {
         await setupMockContext('test-object-id', 'https://storage.example.com/file.mp4');
         mockExec(JSON.stringify({ streams: [{ codec_type: 'video' }] }));
 
@@ -86,7 +86,7 @@ describe('probeMediaStreams', () => {
         expect(result).toEqual({ hasVideo: true, hasAudio: false });
     });
 
-    it('returns hasVideo=false and hasAudio=true for an audio-only container (the bug case)', async () => {
+    it('should return hasVideo=false and hasAudio=true for an audio-only container (the bug case)', async () => {
         await setupMockContext('test-object-id', 'https://storage.example.com/audio-only.mp4');
         mockExec(JSON.stringify({ streams: [{ codec_type: 'audio' }] }));
 
@@ -95,7 +95,7 @@ describe('probeMediaStreams', () => {
         expect(result).toEqual({ hasVideo: false, hasAudio: true });
     });
 
-    it('throws nonRetryable ApplicationFailure when no usable streams are found', async () => {
+    it('should throw nonRetryable ApplicationFailure when no usable streams are found', async () => {
         await setupMockContext('test-object-id', 'https://storage.example.com/bad.mp4');
         mockExec(JSON.stringify({ streams: [] }));
 
@@ -104,7 +104,7 @@ describe('probeMediaStreams', () => {
         );
     });
 
-    it('throws DocumentNotFoundError when the object has no source', async () => {
+    it('should throw DocumentNotFoundError when the object has no source', async () => {
         const { setupActivity } = await import('../../dsl/setup/ActivityContext.js');
         const mockClient = {
             objects: {
@@ -116,11 +116,9 @@ describe('probeMediaStreams', () => {
             client: mockClient,
             objectId: 'test-object-id',
             inputType: 'objectIds',
-            params: {},
+            params: {} satisfies ProbeMediaStreamsParams,
         } as unknown as ActivityContext<ProbeMediaStreamsParams>);
 
-        await expect(testEnv.run(probeMediaStreams, createPayload())).rejects.toThrow(
-            'has no source',
-        );
+        await expect(testEnv.run(probeMediaStreams, createPayload())).rejects.toThrow('has no source');
     });
 });

package/src/activities/media/probeMediaStreams.ts

@@ -1,8 +1,8 @@
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
 import { ApplicationFailure, log } from '@temporalio/activity';
-import { DSLActivityExecutionPayload, DSLActivitySpec } from '@vertesia/common';
 import { RequestError } from '@vertesia/api-fetch-client';
-import { exec } from 'child_process';
-import { promisify } from 'util';
+import type { DSLActivityExecutionPayload, DSLActivitySpec } from '@vertesia/common';
 import { setupActivity } from '../../dsl/setup/ActivityContext.js';
 import { DocumentNotFoundError } from '../../errors.js';
 
@@ -15,8 +15,7 @@ export interface ProbeMediaStreamsResult {
     hasAudio: boolean;
 }
 
-// eslint-disable-next-line @typescript-eslint/no-empty-object-type
-export interface ProbeMediaStreamsParams {}
+export type ProbeMediaStreamsParams = Record<string, never>;
 
 export interface ProbeMediaStreams extends DSLActivitySpec<ProbeMediaStreamsParams> {
     name: 'probeMediaStreams';
@@ -30,7 +29,9 @@ interface FFProbeOutput {
     streams: FFProbeStream[];
 }
 
-export async function probeMediaStreams(payload: DSLActivityExecutionPayload<ProbeMediaStreamsParams>): Promise<ProbeMediaStreamsResult> {
+export async function probeMediaStreams(
+    payload: DSLActivityExecutionPayload<ProbeMediaStreamsParams>,
+): Promise<ProbeMediaStreamsResult> {
     const { client, objectId } = await setupActivity<ProbeMediaStreamsParams>(payload);
 
     const inputObject = await client.objects.retrieve(objectId).catch((err: unknown) => {
@@ -55,10 +56,9 @@ export async function probeMediaStreams(payload: DSLActivityExecutionPayload<Pro
     // -probesize 32k caps the amount read from the network to ~32 KB.
     let stdout: string;
     try {
-        ({ stdout } = await execAsync(
-            `ffprobe -v quiet -probesize 32k -print_format json -show_streams "${url}"`,
-            { maxBuffer: FFPROBE_MAX_BUFFER },
-        ));
+        ({ stdout } = await execAsync(`ffprobe -v quiet -probesize 32k -print_format json -show_streams "${url}"`, {
+            maxBuffer: FFPROBE_MAX_BUFFER,
+        }));
     } catch (err: unknown) {
         const message = err instanceof Error ? err.message : String(err);
         log.error(`ffprobe failed for object ${objectId}: ${message}`);
@@ -66,15 +66,13 @@ export async function probeMediaStreams(payload: DSLActivityExecutionPayload<Pro
     }
 
     const { streams } = JSON.parse(stdout) as FFProbeOutput;
-    const hasVideo = streams.some(s => s.codec_type === 'video');
-    const hasAudio = streams.some(s => s.codec_type === 'audio');
+    const hasVideo = streams.some((s) => s.codec_type === 'video');
+    const hasAudio = streams.some((s) => s.codec_type === 'audio');
 
     log.info(`Media probe result for object ${objectId}`, { hasVideo, hasAudio });
 
     if (!hasVideo && !hasAudio) {
-        throw ApplicationFailure.nonRetryable(
-            `No audio or video streams found in container for object ${objectId}`,
-        );
+        throw ApplicationFailure.nonRetryable(`No audio or video streams found in container for object ${objectId}`);
     }
 
     return { hasVideo, hasAudio };

package/src/activities/media/processPdfWithTextract.ts

@@ -10,18 +10,22 @@
  *  </page>
  */
 
-import { fromWebToken } from "@aws-sdk/credential-providers";
-import { AwsConfiguration, CreateContentObjectPayload, DSLActivityExecutionPayload, DSLActivitySpec, SupportedIntegrations } from "@vertesia/common";
-import type { AwsCredentialIdentityProvider } from "@smithy/types";
-import { log } from "@temporalio/activity";
-import { TextractProcessor } from "../../conversion/TextractProcessor.js";
-import { setupActivity } from "../../dsl/setup/ActivityContext.js";
-import { DocumentNotFoundError } from "../../errors.js";
-import { TextExtractionResult, TextExtractionStatus } from "../../result-types.js";
-import { fetchBlobAsBuffer, md5 } from "../../utils/blobs.js";
-import { countTokens } from "../../utils/tokens.js";
-
-
+import { fromWebToken } from '@aws-sdk/credential-providers';
+import type { AwsCredentialIdentityProvider } from '@smithy/types';
+import { log } from '@temporalio/activity';
+import {
+    type AwsConfiguration,
+    type CreateContentObjectPayload,
+    type DSLActivityExecutionPayload,
+    type DSLActivitySpec,
+    SupportedIntegrations,
+} from '@vertesia/common';
+import { TextractProcessor } from '../../conversion/TextractProcessor.js';
+import { setupActivity } from '../../dsl/setup/ActivityContext.js';
+import { DocumentNotFoundError } from '../../errors.js';
+import { type TextExtractionResult, TextExtractionStatus } from '../../result-types.js';
+import { fetchBlobAsBuffer, md5 } from '../../utils/blobs.js';
+import { countTokens } from '../../utils/tokens.js';
 
 export interface ConvertPdfToStructuredTextParams {
     force?: boolean;
@@ -35,48 +39,54 @@ export interface StructuredTextResult extends TextExtractionResult {
     message?: string;
 }
 
-
-
-export async function convertPdfToStructuredText(payload: DSLActivityExecutionPayload<ConvertPdfToStructuredTextParams>): Promise<StructuredTextResult> {
-
-
+export async function convertPdfToStructuredText(
+    payload: DSLActivityExecutionPayload<ConvertPdfToStructuredTextParams>,
+): Promise<StructuredTextResult> {
     const { params, client, objectId } = await setupActivity<ConvertPdfToStructuredTextParams>(payload);
 
-    const object = await client.objects.retrieve(objectId, "+text");
+    const object = await client.objects.retrieve(objectId, '+text');
 
     if (object.text && !params.force) {
-        return { hasText: true, objectId, status: TextExtractionStatus.skipped, message: "text already present and force not enabled" }
+        return {
+            hasText: true,
+            objectId,
+            status: TextExtractionStatus.skipped,
+            message: 'text already present and force not enabled',
+        };
     }
 
     if (!object.content?.source) {
         throw new DocumentNotFoundError(`No source found for object ${objectId}`);
     }
 
-    const pdfUrl = await client.store.objects.getContentSource(objectId).then(res => res.source);
+    const pdfUrl = await client.store.objects.getContentSource(objectId).then((res) => res.source);
 
     if (!pdfUrl) {
         throw new DocumentNotFoundError(`Error fetching source ${object.content.source}`);
     }
 
     const project = await client.getProject();
-    const awsConfig = (await client.projects.integrations.retrieve(project!.id, SupportedIntegrations.aws)) as AwsConfiguration;
-    const credentials = await getS3AWSCredentials(awsConfig, payload.auth_token, project!.id);
+    if (!project?.id) {
+        throw new Error('Project id not available on client');
+    }
+    const awsConfig = (await client.projects.integrations.retrieve(
+        project.id,
+        SupportedIntegrations.aws,
+    )) as AwsConfiguration;
+    const credentials = await getS3AWSCredentials(awsConfig, payload.auth_token, project.id);
 
     const processor = new TextractProcessor({
         fileKey: objectId,
-        region: "us-west-2",
-        bucket: "cp-textract-tests",
+        region: 'us-west-2',
+        bucket: 'cp-textract-tests',
         credentials,
         log: log,
         detectImages: true,
         includeConfidenceInTables: true,
     });
 
-
-
     try {
-
-        if (!object.content.source.startsWith("s3://")) {
+        if (!object.content.source.startsWith('s3://')) {
             const buf = await fetchBlobAsBuffer(client, object.content.source);
             await processor.upload(buf);
         }
@@ -84,12 +94,12 @@ export async function convertPdfToStructuredText(payload: DSLActivityExecutionPa
         const jobId = await processor.startAnalysis(objectId);
 
         let jobStatus = await processor.checkJobStatus(jobId);
-        while (jobStatus === "IN_PROGRESS") {
-            await new Promise(resolve => setTimeout(resolve, 5000));
+        while (jobStatus === 'IN_PROGRESS') {
+            await new Promise((resolve) => setTimeout(resolve, 5000));
             jobStatus = await processor.checkJobStatus(jobId);
         }
 
-        if (jobStatus === "SUCCEEDED") {
+        if (jobStatus === 'SUCCEEDED') {
             log.info(`Job ${jobId} succeeded, saving results`, { jobId });
             const fText = await processor.processResults(jobId);
             const tokensData = countTokens(fText);
@@ -100,36 +110,45 @@ export async function convertPdfToStructuredText(payload: DSLActivityExecutionPa
                 tokens: {
                     ...tokensData,
                     etag: etag,
-                }
-            }
+                },
+            };
 
             await client.objects.update(objectId, updateData);
-            console.log("Full text updated");
-
-            return { hasText: true, objectId, status: TextExtractionStatus.success, message: "Text extracted successfully" }
-
+            console.log('Full text updated');
+
+            return {
+                hasText: true,
+                objectId,
+                status: TextExtractionStatus.success,
+                message: 'Text extracted successfully',
+            };
         } else {
             throw new Error(`Job failed with status: ${jobStatus}`);
         }
     } catch (error) {
-        console.error("Error processing document:", error);
+        console.error('Error processing document:', error);
         throw error;
     }
-
-
 }
 
-export async function getS3AWSCredentials(awsConfig: AwsConfiguration, composableAuthToken: string, projectId: string): Promise<AwsCredentialIdentityProvider> {
-
+export async function getS3AWSCredentials(
+    awsConfig: AwsConfiguration,
+    composableAuthToken: string,
+    projectId: string,
+): Promise<AwsCredentialIdentityProvider> {
     // fetch s3 role ARN
-    if (!awsConfig || !awsConfig.enabled) {
-        throw new DocumentNotFoundError("AWS integration is not enabled for this project");
+    if (!awsConfig?.enabled) {
+        throw new DocumentNotFoundError('AWS integration is not enabled for this project');
     }
     if (!awsConfig.s3_role_arn) {
-        throw new DocumentNotFoundError("S3 Role ARN is not defined in AWS project integration");
+        throw new DocumentNotFoundError('S3 Role ARN is not defined in AWS project integration');
     }
 
-    log.info("Getting AWS credentials for Textract", { projectId, composableAuthToken, roleArn: awsConfig.s3_role_arn });
+    log.info('Getting AWS credentials for Textract', {
+        projectId,
+        composableAuthToken,
+        roleArn: awsConfig.s3_role_arn,
+    });
 
     const credentials = fromWebToken({
         webIdentityToken: composableAuthToken,