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

package/src/dsl/setup/ActivityContext.ts

@@ -1,42 +1,26 @@
-import { log, activityInfo } from "@temporalio/activity";
-import { VertesiaClient } from "@vertesia/client";
-import {
+import { activityInfo, log } from '@temporalio/activity';
+import type { VertesiaClient } from '@vertesia/client';
+import type {
     DSLActivityExecutionPayload,
     DSLWorkflowExecutionPayload,
     Project,
     WorkflowExecutionPayload,
-    WorkflowInputType,
     WorkflowInputFile,
-} from "@vertesia/common";
-import {
-    DocumentNotFoundError,
-    WorkflowParamNotFoundError,
-    WorkflowExecutionError,
-} from "../../errors.js";
-import { getProjectFromToken } from "../../utils/auth.js";
-import { getVertesiaClient } from "../../utils/client.js";
-import { Vars } from "../vars.js";
-import {
-    getFetchProvider,
-    registerFetchProviderFactory,
-} from "./fetch/index.js";
-import {
-    DocumentProvider,
-    DocumentTypeProvider,
-    InteractionRunProvider,
-} from "./fetch/providers.js";
+    WorkflowInputType,
+} from '@vertesia/common';
+import { DocumentNotFoundError, WorkflowExecutionError, WorkflowParamNotFoundError } from '../../errors.js';
+import { activityWorkflowExecution } from '../../utils/activity-info.js';
+import { getProjectFromToken } from '../../utils/auth.js';
+import { getVertesiaClient } from '../../utils/client.js';
+import { Vars } from '../vars.js';
+import { getFetchProvider, registerFetchProviderFactory } from './fetch/index.js';
+import { DocumentProvider, DocumentTypeProvider, InteractionRunProvider } from './fetch/providers.js';
 
 registerFetchProviderFactory(DocumentProvider.ID, DocumentProvider.factory);
-registerFetchProviderFactory(
-    DocumentTypeProvider.ID,
-    DocumentTypeProvider.factory,
-);
-registerFetchProviderFactory(
-    InteractionRunProvider.ID,
-    InteractionRunProvider.factory,
-);
+registerFetchProviderFactory(DocumentTypeProvider.ID, DocumentTypeProvider.factory);
+registerFetchProviderFactory(InteractionRunProvider.ID, InteractionRunProvider.factory);
 
-export class ActivityContext<ParamsT extends Record<string, any>> {
+export class ActivityContext<ParamsT extends object> {
     client: VertesiaClient;
     _project?: Promise<Project | undefined>;
 
@@ -54,15 +38,12 @@ export class ActivityContext<ParamsT extends Record<string, any>> {
     }
 
     get objectId() {
-        const objectId = this.payload.objectIds && this.payload.objectIds[0];
+        const objectId = this.payload.objectIds?.[0];
         if (!objectId) {
-            log.error("No objectId found in payload");
+            log.error('No objectId found in payload');
             throw new WorkflowParamNotFoundError(
-                "objectIds[0]",
-                (
-                    this
-                        .payload as WorkflowExecutionPayload as DSLWorkflowExecutionPayload
-                ).workflow,
+                'objectIds[0]',
+                (this.payload as WorkflowExecutionPayload as DSLWorkflowExecutionPayload).workflow,
             );
         }
         return objectId;
@@ -73,30 +54,24 @@ export class ActivityContext<ParamsT extends Record<string, any>> {
     }
 
     get runId() {
-        const runId = activityInfo().workflowExecution.runId;
+        const runId = activityWorkflowExecution().runId;
         if (!runId) {
-            log.error("No runId found in activityInfo");
+            log.error('No runId found in activityInfo');
             throw new WorkflowParamNotFoundError(
-                "runId",
-                (
-                    this
-                        .payload as WorkflowExecutionPayload as DSLWorkflowExecutionPayload
-                ).workflow,
+                'runId',
+                (this.payload as WorkflowExecutionPayload as DSLWorkflowExecutionPayload).workflow,
             );
         }
         return runId;
     }
 
     get workflowId() {
-        const workflowId = activityInfo().workflowExecution.workflowId;
+        const workflowId = activityWorkflowExecution().workflowId;
         if (!workflowId) {
-            log.error("No workflowId found in activityInfo");
+            log.error('No workflowId found in activityInfo');
             throw new WorkflowParamNotFoundError(
-                "workflowId",
-                (
-                    this
-                        .payload as WorkflowExecutionPayload as DSLWorkflowExecutionPayload
-                ).workflow,
+                'workflowId',
+                (this.payload as WorkflowExecutionPayload as DSLWorkflowExecutionPayload).workflow,
             );
         }
         return workflowId;
@@ -119,20 +94,15 @@ export class ActivityContext<ParamsT extends Record<string, any>> {
     get file(): WorkflowInputFile {
         const input = this.payload.input;
         if (!input || input.inputType !== 'files') {
-            throw new WorkflowExecutionError(
-                'Activity expects files but received objectIds'
-            );
+            throw new WorkflowExecutionError('Activity expects files but received objectIds');
         }
         // TypeScript now knows input is { inputType: 'files', files: WorkflowInputFile[] }
         const files = input.files;
         if (!files || files.length === 0) {
-            log.error("No files found in payload");
+            log.error('No files found in payload');
             throw new WorkflowParamNotFoundError(
-                "files[0]",
-                (
-                    this
-                        .payload as WorkflowExecutionPayload as DSLWorkflowExecutionPayload
-                ).workflow,
+                'files[0]',
+                (this.payload as WorkflowExecutionPayload as DSLWorkflowExecutionPayload).workflow,
             );
         }
         return files[0];
@@ -146,9 +116,7 @@ export class ActivityContext<ParamsT extends Record<string, any>> {
     get files(): WorkflowInputFile[] {
         const input = this.payload.input;
         if (!input || input.inputType !== 'files') {
-            throw new WorkflowExecutionError(
-                'Activity expects files but received objectIds'
-            );
+            throw new WorkflowExecutionError('Activity expects files but received objectIds');
         }
         // TypeScript now knows input is { inputType: 'files', files: WorkflowInputFile[] }
         return input.files;
@@ -169,7 +137,7 @@ export class ActivityContext<ParamsT extends Record<string, any>> {
      * For files, returns an array of URLs.
      */
     get inputs(): string[] {
-        return this.inputType === 'objectIds' ? (this.objectIds || []) : this.files.map(f => f.url);
+        return this.inputType === 'objectIds' ? this.objectIds || [] : this.files.map((f) => f.url);
     }
 
     fetchProject() {
@@ -180,9 +148,7 @@ export class ActivityContext<ParamsT extends Record<string, any>> {
     }
 }
 
-export async function setupActivity<ParamsT extends Record<string, any>>(
-    payload: DSLActivityExecutionPayload<ParamsT>,
-) {
+export async function setupActivity<ParamsT extends object>(payload: DSLActivityExecutionPayload<ParamsT>) {
     const client = await getVertesiaClient(payload);
 
     // Activities dispatched from TypeScript code (via dslProxyActivities) set
@@ -191,8 +157,7 @@ export async function setupActivity<ParamsT extends Record<string, any>>(
     // `${...}` in user-supplied strings as a variable reference and silently
     // drop the key when it fails to resolve. Only DSL-defined activities
     // (which carry `activity.params` and/or `activity.fetch`) need Vars.
-    const isDslDispatched =
-        payload.activity.params !== undefined || payload.activity.fetch !== undefined;
+    const isDslDispatched = payload.activity.params !== undefined || payload.activity.fetch !== undefined;
 
     if (!isDslDispatched) {
         const params = (payload.params ?? {}) as ParamsT;
@@ -230,10 +195,7 @@ export async function setupActivity<ParamsT extends Record<string, any>>(
 
                 const provider = getFetchProvider(client, fetchSpec);
 
-                log.info(
-                    `Fetching data for ${key} with provider ${provider.name}`,
-                    { fetchSpec },
-                );
+                log.info(`Fetching data for ${key} with provider ${provider.name}`, { fetchSpec });
                 const result = await provider.fetch(fetchSpec);
                 if (result && result.length > 0) {
                     if (fetchSpec.limit === 1) {
@@ -241,10 +203,8 @@ export async function setupActivity<ParamsT extends Record<string, any>>(
                     } else {
                         vars.setValue(key, result);
                     }
-                } else if (fetchSpec.on_not_found === "throw") {
-                    throw new DocumentNotFoundError(
-                        "No documents found for: " + JSON.stringify(fetchSpec),
-                    );
+                } else if (fetchSpec.on_not_found === 'throw') {
+                    throw new DocumentNotFoundError(`No documents found for: ${JSON.stringify(fetchSpec)}`);
                 } else {
                     vars.setValue(key, null);
                 }
@@ -256,10 +216,7 @@ export async function setupActivity<ParamsT extends Record<string, any>>(
     return new ActivityContext<ParamsT>(payload, client, params);
 }
 
-async function _fetchProject(
-    client: VertesiaClient,
-    payload: WorkflowExecutionPayload,
-) {
+async function _fetchProject(client: VertesiaClient, payload: WorkflowExecutionPayload) {
     const project = await getProjectFromToken(payload.auth_token);
     return project ? await client.projects.retrieve(project.id) : undefined;
 }

package/src/dsl/setup/fetch/DataProvider.ts

@@ -1,10 +1,10 @@
-import { FindPayload } from "@vertesia/common";
+import type { FindPayload } from '@vertesia/common';
 
 function parseSelector(selector: string) {
     const parts = selector.split(/\s+/);
     const result: Record<string, number> = {};
     for (const part of parts) {
-        if (part.startsWith("-")) {
+        if (part.startsWith('-')) {
             result[part.substring(1)] = 0;
         } else {
             result[part] = 1;
@@ -13,7 +13,7 @@ function parseSelector(selector: string) {
     return result;
 }
 
-function applyProjection(result: Record<string, any>, select: string) {
+function applyProjection(result: Record<string, unknown>, select: string) {
     if (!result) return result;
     let selectorObj: Record<string, number | boolean>;
     if (typeof select === 'string') {
@@ -22,7 +22,7 @@ function applyProjection(result: Record<string, any>, select: string) {
         selectorObj = select;
     }
 
-    const out: Record<string, any> = {};
+    const out: Record<string, unknown> = {};
     for (const key of Object.keys(result)) {
         if (selectorObj[key]) {
             out[key] = result[key];
@@ -32,14 +32,17 @@ function applyProjection(result: Record<string, any>, select: string) {
 }
 
 export abstract class DataProvider {
-    constructor(public name: string, public isProjectionSupported = false) {
-    }
+    constructor(
+        public name: string,
+        public isProjectionSupported = false,
+    ) {}
     async fetch(payload: FindPayload) {
         let results = await this.doFetch(payload);
         if (payload.select && !this.isProjectionSupported) {
-            results = results.map((result: Record<string, any>) => applyProjection(result, payload.select!));
+            // biome-ignore lint/style/noNonNullAssertion: intentional non-null assertion; TS can't prove narrowing here
+            results = results.map((result: Record<string, unknown>) => applyProjection(result, payload.select!));
         }
         return results;
     }
-    abstract doFetch(payload: FindPayload): Promise<Record<string, any>[]>;
+    abstract doFetch(payload: FindPayload): Promise<Record<string, unknown>[]>;
 }

package/src/dsl/setup/fetch/index.ts

@@ -1,19 +1,17 @@
-import { ActivityFetchSpec } from "@vertesia/common";
-import { VertesiaClient } from "@vertesia/client";
-import { DataProvider } from "./DataProvider.js";
+import type { VertesiaClient } from '@vertesia/client';
+import type { ActivityFetchSpec } from '@vertesia/common';
+import type { DataProvider } from './DataProvider.js';
 
+const factories: Record<string, (client: VertesiaClient, source?: string) => DataProvider> = {};
 
-const factories: Record<string, ((client: VertesiaClient, source?: string) => DataProvider)> = {};
-
-
-export function registerFetchProviderFactory(name: string, factory: ((client: VertesiaClient) => DataProvider)) {
+export function registerFetchProviderFactory(name: string, factory: (client: VertesiaClient) => DataProvider) {
     factories[name] = factory;
 }
 
 export function getFetchProvider(client: VertesiaClient, fetchSpec: ActivityFetchSpec) {
     const factory = factories[fetchSpec.type];
     if (!factory) {
-        throw new Error("Unknown data provider: " + fetchSpec.source);
+        throw new Error(`Unknown data provider: ${fetchSpec.source}`);
     }
     return factory(client, fetchSpec.source);
 }

package/src/dsl/setup/fetch/providers.ts

@@ -1,27 +1,34 @@
-import { FindPayload } from "@vertesia/common";
-import { VertesiaClient } from "@vertesia/client";
-import { DataProvider } from "./DataProvider.js";
+import type { VertesiaClient } from '@vertesia/client';
+import type { FindPayload } from '@vertesia/common';
+import { DataProvider } from './DataProvider.js';
 
-function useMongoId(query: Record<string, any>) {
+function useMongoId(query: Record<string, unknown>) {
     if (query.id) {
-        const result = { ...query, _id: query.id }
-        delete (result as any).id;
-        return result;
+        const { id, ...rest } = query;
+        return { ...rest, _id: id };
     }
     return query;
 }
 
+function asRecords<T extends object>(items: T[]): Record<string, unknown>[] {
+    return items as unknown as Record<string, unknown>[];
+}
+
 export class DocumentProvider extends DataProvider {
-    static ID = "document";
+    static ID = 'document';
     constructor(public client: VertesiaClient) {
         super(DocumentProvider.ID, true);
     }
 
-    doFetch(payload: FindPayload): Promise<Record<string, any>[]> {
+    doFetch(payload: FindPayload): Promise<Record<string, unknown>[]> {
         const query = useMongoId(payload.query);
-        return this.client.objects.find({
-            query, select: payload.select, limit: payload.limit
-        });
+        return this.client.objects
+            .find({
+                query,
+                select: payload.select,
+                limit: payload.limit,
+            })
+            .then(asRecords);
     }
 
     static factory(client: VertesiaClient) {
@@ -30,16 +37,20 @@ export class DocumentProvider extends DataProvider {
 }
 
 export class DocumentTypeProvider extends DataProvider {
-    static ID = "document_type";
+    static ID = 'document_type';
     constructor(public client: VertesiaClient) {
         super(DocumentTypeProvider.ID, true);
     }
 
-    doFetch(payload: FindPayload): Promise<Record<string, any>[]> {
+    doFetch(payload: FindPayload): Promise<Record<string, unknown>[]> {
         const query = useMongoId(payload.query);
-        return this.client.types.find({
-            query, select: payload.select, limit: payload.limit
-        });
+        return this.client.types
+            .find({
+                query,
+                select: payload.select,
+                limit: payload.limit,
+            })
+            .then(asRecords);
     }
 
     static factory(client: VertesiaClient) {
@@ -48,20 +59,23 @@ export class DocumentTypeProvider extends DataProvider {
 }
 
 export class InteractionRunProvider extends DataProvider {
-    static ID = "interaction_run";
+    static ID = 'interaction_run';
     constructor(public client: VertesiaClient) {
         super(DocumentProvider.ID, true);
     }
 
-    doFetch(payload: FindPayload): Promise<Record<string, any>[]> {
+    doFetch(payload: FindPayload): Promise<Record<string, unknown>[]> {
         const query = useMongoId(payload.query);
-        return this.client.runs.find({
-            query, select: payload.select, limit: payload.limit
-        });
+        return this.client.runs
+            .find({
+                query,
+                select: payload.select,
+                limit: payload.limit,
+            })
+            .then(asRecords);
     }
 
     static factory(client: VertesiaClient) {
         return new InteractionRunProvider(client);
     }
-
-}
+}

package/src/dsl/test/test-child-workflow.ts

@@ -1,5 +1,6 @@
-import { WorkflowExecutionPayload } from "@vertesia/common";
-export { dslWorkflow } from "../dsl-workflow.js";
+import type { WorkflowExecutionPayload } from '@vertesia/common';
+
+export { dslWorkflow } from '../dsl-workflow.js';
 
 export async function testChildWorkflow(payload: WorkflowExecutionPayload) {
     return `Child: Hello, ${payload.vars.name}!`;