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

package/src/dsl/dslProxyActivities.ts

@@ -1,38 +1,58 @@
-import { ActivityOptions, proxyActivities } from "@temporalio/workflow";
-import { DSLActivityExecutionPayload, WorkflowExecutionBaseParams, WorkflowExecutionPayload } from "@vertesia/common";
+import { type ActivityOptions, proxyActivities } from '@temporalio/workflow';
+import type {
+    DSLActivityExecutionPayload,
+    WorkflowExecutionBaseParams,
+    WorkflowExecutionPayload,
+} from '@vertesia/common';
 
-export interface DslActivityFunction<ParamsT extends Record<string, any> = any, ReturnT = any> {
-    (payload: DSLActivityExecutionPayload<ParamsT>): Promise<ReturnT>;
-}
+export type DslActivityFunction<ParamsT extends object = Record<string, unknown>, ReturnT = unknown> = (
+    payload: DSLActivityExecutionPayload<ParamsT>,
+) => Promise<ReturnT>;
+
+export type DslSimplifiedActivityFunction<ParamsT extends object = Record<string, unknown>, ReturnT = unknown> = (
+    payload: WorkflowExecutionBaseParams<unknown>,
+    params: ParamsT,
+) => Promise<ReturnT>;
+
+export function stripWorkflowContinuationFromVars<T>(vars: T): T {
+    if (!vars || typeof vars !== 'object' || Array.isArray(vars) || !('_continuation' in vars)) {
+        return vars;
+    }
 
-export interface DslSimplifiedActivityFunction<ParamsT = any, ReturnT = any> {
-    (payload: WorkflowExecutionBaseParams, params: ParamsT): Promise<ReturnT>;
+    const rest = { ...(vars as Record<string, unknown>) };
+    delete rest._continuation;
+    return rest as T;
 }
 
-export function dslProxyActivities<
-    ActivitiesT extends Record<string, DslActivityFunction<any, any>>
->(workflowName: string, options: ActivityOptions = {}) {
+export function dslProxyActivities<ActivitiesT extends object>(workflowName: string, options: ActivityOptions = {}) {
     type DslActivities = {
         [K in keyof ActivitiesT]: ActivitiesT[K] extends DslActivityFunction<infer ParamsT, infer ReturnT>
-        ? DslSimplifiedActivityFunction<ParamsT, ReturnT>
-        : never;
+            ? DslSimplifiedActivityFunction<ParamsT, ReturnT>
+            : never;
     };
 
     const activities = proxyActivities<ActivitiesT>(options) as ActivitiesT;
 
-    return new Proxy({}, {
-        get(_target, prop) {
-            const activityFn = activities[prop as keyof ActivitiesT] as DslActivityFunction;
-            return (payload: WorkflowExecutionPayload, params: any) => {
-                return activityFn({
-                    ...payload,
-                    activity: {
-                        name: prop as string,
-                    },
-                    workflow_name: workflowName,
-                    params,
-                });
-            };
+    return new Proxy(
+        {},
+        {
+            get(_target, prop) {
+                const activityFn = activities[prop as keyof ActivitiesT] as unknown as DslActivityFunction<
+                    Record<string, unknown>,
+                    unknown
+                >;
+                return (payload: WorkflowExecutionPayload, params: Record<string, unknown>) => {
+                    return activityFn({
+                        ...payload,
+                        vars: stripWorkflowContinuationFromVars(payload.vars),
+                        activity: {
+                            name: prop as string,
+                        },
+                        workflow_name: workflowName,
+                        params,
+                    });
+                };
+            },
         },
-    }) as unknown as DslActivities;
+    ) as unknown as DslActivities;
 }

package/src/dsl/ms.d.ts

@@ -1,11 +1,42 @@
 /**
  * Types for the `ms` package (version 3.0.0-canary.1)
  */
-declare module "ms" {
-    declare type Unit = 'Years' | 'Year' | 'Yrs' | 'Yr' | 'Y' | 'Weeks' | 'Week' | 'W' | 'Days' | 'Day' | 'D' | 'Hours' | 'Hour' | 'Hrs' | 'Hr' | 'H' | 'Minutes' | 'Minute' | 'Mins' | 'Min' | 'M' | 'Seconds' | 'Second' | 'Secs' | 'Sec' | 's' | 'Milliseconds' | 'Millisecond' | 'Msecs' | 'Msec' | 'Ms';
+declare module 'ms' {
+    declare type Unit =
+        | 'Years'
+        | 'Year'
+        | 'Yrs'
+        | 'Yr'
+        | 'Y'
+        | 'Weeks'
+        | 'Week'
+        | 'W'
+        | 'Days'
+        | 'Day'
+        | 'D'
+        | 'Hours'
+        | 'Hour'
+        | 'Hrs'
+        | 'Hr'
+        | 'H'
+        | 'Minutes'
+        | 'Minute'
+        | 'Mins'
+        | 'Min'
+        | 'M'
+        | 'Seconds'
+        | 'Second'
+        | 'Secs'
+        | 'Sec'
+        | 's'
+        | 'Milliseconds'
+        | 'Millisecond'
+        | 'Msecs'
+        | 'Msec'
+        | 'Ms';
     declare type UnitAnyCase = Unit | Uppercase<Unit> | Lowercase<Unit>;
     export declare type StringValue = `${number}` | `${number}${UnitAnyCase}` | `${number} ${UnitAnyCase}`;
     declare function ms(value: StringValue, options?: Options): number;
     declare function ms(value: number, options?: Options): string;
     export default ms;
-}
+}

package/src/dsl/projections.test.ts

@@ -1,159 +1,167 @@
-import { describe, test, expect } from "vitest";
-import { Vars } from "./vars.ts";
-import { makeProjection } from "./projections.ts";
+import { describe, expect, test } from 'vitest';
+import { makeProjection } from './projections.js';
 
 describe('Result Projections', () => {
-
-    test('simple projection', () => {
-        const params: Record<string, any> = {
-            docTypes: [{ id: 1, name: "type1" }, { id: 2, name: "type2" }],
-            objectId: "123"
-        }
+    test('should make a simple projection', () => {
+        const params: Record<string, unknown> = {
+            docTypes: [
+                { id: 1, name: 'type1' },
+                { id: 2, name: 'type2' },
+            ],
+            objectId: '123',
+        };
         const result = {
             result: {
-                document_type: "C",
-            }
-        }
+                document_type: 'C',
+            },
+        };
         const spec = {
-            docType: "${docTypes[0].name}",
-            objectId: "${objectId}",
-            resultType: "${#.result.document_type}",
-            timestamp: 123456
-        }
+            docType: '${docTypes[0].name}',
+            objectId: '${objectId}',
+            resultType: '${#.result.document_type}',
+            timestamp: 123456,
+        };
         const out = makeProjection(spec, params, result);
 
         expect(Object.keys(out).length).toBe(4);
-        expect(out.docType).toBe("type1");
-        expect(out.objectId).toBe("123");
-        expect(out.resultType).toBe("C");
+        expect(out.docType).toBe('type1');
+        expect(out.objectId).toBe('123');
+        expect(out.resultType).toBe('C');
         expect(out.timestamp).toBe(123456);
         expect(out.foo).toBeUndefined();
-    })
-
-    test('$element match', () => {
-        const params: Record<string, any> = {
-            docTypes: [{ id: 1, name: "type1" }, { id: 2, name: "type2" }],
-            objectId: "123"
-        }
+    });
+
+    test('should resolve $element match', () => {
+        const params: Record<string, unknown> = {
+            docTypes: [
+                { id: 1, name: 'type1' },
+                { id: 2, name: 'type2' },
+            ],
+            objectId: '123',
+        };
         const result = {
             result: {
-                document_type: "type2",
-            }
-        }
+                document_type: 'type2',
+            },
+        };
         const spec = {
             docType: {
                 $element: {
-                    from: "${docTypes}",
-                    where: { name: { $eq: "${#.result.document_type}" } },
-                    else: { id: 0, name: "unknown" }
-                }
+                    from: '${docTypes}',
+                    where: { name: { $eq: '${#.result.document_type}' } },
+                    else: { id: 0, name: 'unknown' },
+                },
             },
             isNewType: {
                 $eval: {
-                    "#.result.document_type": { $nin: "${docTypes.name}" }
-                }
-            }
-        }
+                    '#.result.document_type': { $nin: '${docTypes.name}' },
+                },
+            },
+        };
 
         const out = makeProjection(spec, params, result);
 
-
         expect(Object.keys(out).length).toBe(2);
-        expect(out.docType).toStrictEqual({ id: 2, name: "type2" });
+        expect(out.docType).toStrictEqual({ id: 2, name: 'type2' });
         expect(out.isNewType).toBe(false);
-    })
-
-    test('$element does not match', () => {
-        const params: Record<string, any> = {
-            docTypes: [{ id: 1, name: "type1" }, { id: 2, name: "type2" }],
-            objectId: "123"
-        }
+    });
+
+    test('should resolve $element fallback when it does not match', () => {
+        const params: Record<string, unknown> = {
+            docTypes: [
+                { id: 1, name: 'type1' },
+                { id: 2, name: 'type2' },
+            ],
+            objectId: '123',
+        };
         const result = {
             result: {
-                document_type: "a_new_type",
-            }
-        }
+                document_type: 'a_new_type',
+            },
+        };
         const projection = {
             docType: {
                 $element: {
-                    from: "${docTypes}",
-                    where: { name: { $eq: "${#.result.document_type}" } },
-                    else: { id: 0, name: "${#.result.document_type}" }
-                }
+                    from: '${docTypes}',
+                    where: { name: { $eq: '${#.result.document_type}' } },
+                    else: { id: 0, name: '${#.result.document_type}' },
+                },
             },
             isNewType: {
                 $eval: {
-                    "#.result.document_type": { $nin: "${docTypes.name}" }
-                }
-            }
-        }
+                    '#.result.document_type': { $nin: '${docTypes.name}' },
+                },
+            },
+        };
 
         const out = makeProjection(projection, params, result);
 
-
         expect(Object.keys(out).length).toBe(2);
-        expect(out.docType).toStrictEqual({ id: 0, name: "a_new_type" });
+        expect(out.docType).toStrictEqual({ id: 0, name: 'a_new_type' });
         expect(out.isNewType).toBe(true);
-    })
-
-    test('$element with field', () => {
-        const params: Record<string, any> = {
-            docTypes: [{ id: 1, name: "type1" }, { id: 2, name: "type2" }],
-            objectId: "123"
-        }
+    });
+
+    test('should resolve $element with field', () => {
+        const params: Record<string, unknown> = {
+            docTypes: [
+                { id: 1, name: 'type1' },
+                { id: 2, name: 'type2' },
+            ],
+            objectId: '123',
+        };
         const result = {
             result: {
-                document_type: "type2",
-            }
-        }
+                document_type: 'type2',
+            },
+        };
         const projection = {
             other: null,
-            name: "${#.result.document_type}",
+            name: '${#.result.document_type}',
             id: {
                 $element: {
-                    field: "id",
-                    from: "${docTypes}",
-                    where: { name: { $eq: "${#.result.document_type}" } },
-                    else: null
-                }
+                    field: 'id',
+                    from: '${docTypes}',
+                    where: { name: { $eq: '${#.result.document_type}' } },
+                    else: null,
+                },
             },
-        }
+        };
 
         const out = makeProjection(projection, params, result);
 
-
         expect(Object.keys(out).length).toBe(3);
-        expect(out).toStrictEqual({ id: 2, name: "type2", other: null });
-    })
-
-    test('$element with field - no match', () => {
-        const params: Record<string, any> = {
-            docTypes: [{ id: 1, name: "type1" }, { id: 2, name: "type2" }],
-            objectId: "123"
-        }
+        expect(out).toStrictEqual({ id: 2, name: 'type2', other: null });
+    });
+
+    test('should resolve $element with field fallback when it does not match', () => {
+        const params: Record<string, unknown> = {
+            docTypes: [
+                { id: 1, name: 'type1' },
+                { id: 2, name: 'type2' },
+            ],
+            objectId: '123',
+        };
         const result = {
             result: {
-                document_type: "a_new_type",
-            }
-        }
+                document_type: 'a_new_type',
+            },
+        };
         const projection = {
             other: null,
-            name: "${#.result.document_type}",
+            name: '${#.result.document_type}',
             id: {
                 $element: {
-                    field: "id",
-                    from: "${docTypes}",
-                    where: { name: { $eq: "${#.result.document_type}" } },
-                    else: null
-                }
+                    field: 'id',
+                    from: '${docTypes}',
+                    where: { name: { $eq: '${#.result.document_type}' } },
+                    else: null,
+                },
             },
-        }
+        };
 
         const out = makeProjection(projection, params, result);
 
-
         expect(Object.keys(out).length).toBe(3);
-        expect(out).toStrictEqual({ id: null, name: "a_new_type", other: null });
-    })
-
+        expect(out).toStrictEqual({ id: null, name: 'a_new_type', other: null });
+    });
 });

package/src/dsl/projections.ts

@@ -1,45 +1,58 @@
-import { DSLActivityExecutionPayload } from "@vertesia/common";
-import { matchCondition } from "./conditions.js";
-import { Vars } from "./vars.js";
+import type { DSLActivityExecutionPayload } from '@vertesia/common';
+import { matchCondition } from './conditions.js';
+import { Vars } from './vars.js';
 
+type ProjectOperation = (arg: unknown, vars: Vars) => unknown;
 
-interface ProjectOperation {
-    (arg: any, vars: Vars): any
+interface ElementOperation {
+    field?: string;
+    from: unknown[];
+    where: Record<string, unknown>;
+    else: unknown;
 }
 
-interface ElementOperation {
-    field?: string,
-    from: any[],
-    where: Record<string, any>,
-    else: any
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function asRecord(value: object): Record<string, unknown> {
+    return value as Record<string, unknown>;
+}
+
+function isElementOperation(value: unknown): value is ElementOperation {
+    return isRecord(value) && Array.isArray(value.from) && isRecord(value.where);
 }
+
 const operations: Record<string, ProjectOperation> = {
-    $element(arg: ElementOperation, _vars: Vars) {
+    $element(arg: unknown, _vars: Vars) {
+        if (!isElementOperation(arg)) {
+            return undefined;
+        }
         const where = arg.where;
         const whereKeys = Object.keys(where);
-        const r = arg.from.find((elem: any) => {
+        const r = arg.from.find((elem: unknown) => {
             for (const key of whereKeys) {
-                const value = key === '_' ? elem : elem[key];
+                const value = key === '_' ? elem : isRecord(elem) ? elem[key] : undefined;
                 if (matchCondition(value, where[key])) {
                     return true;
                 }
             }
             return false;
-        })
+        });
         if (arg.field) {
-            return r ? r[arg.field] : arg.else;
+            return isRecord(r) ? r[arg.field] : arg.else;
         } else {
             return r || arg.else;
         }
     },
-    $eval(arg: any, vars: Vars) {
-        return vars.match(arg);
-    }
-}
+    $eval(arg: unknown, vars: Vars) {
+        return isRecord(arg) ? vars.match(arg) : false;
+    },
+};
 
-function runProjection(obj: any, vars: Vars) {
-    if (obj && !Array.isArray(obj) && typeof obj === "object") {
-        const keys = Object.keys(obj)
+function runProjection(obj: unknown, vars: Vars) {
+    if (isRecord(obj)) {
+        const keys = Object.keys(obj);
         if (keys.length === 1) {
             const key = keys[0];
             const fn = operations[key];
@@ -51,11 +64,18 @@ function runProjection(obj: any, vars: Vars) {
     return obj; // return the value as is
 }
 
-export function projectResult<TParams extends Record<string, any>>(payload: DSLActivityExecutionPayload<TParams>, params: Record<string, any>, result: any, fallback: any) {
-    return payload.activity.projection ? makeProjection(payload.activity.projection, params, result) : fallback;
+export function projectResult<TParams extends object>(
+    payload: DSLActivityExecutionPayload<TParams>,
+    params: TParams,
+    result: unknown,
+    fallback: unknown,
+) {
+    return payload.activity.projection
+        ? makeProjection(payload.activity.projection, asRecord(params), result)
+        : fallback;
 }
 
-export function makeProjection(spec: Record<string, any>, params: Record<string, any>, result: any) {
+export function makeProjection(spec: Record<string, unknown>, params: Record<string, unknown>, result: unknown) {
     const vars = new Vars({
         ...params,
         '#': result,
@@ -63,7 +83,7 @@ export function makeProjection(spec: Record<string, any>, params: Record<string,
 
     const projection = vars.resolveParams(spec);
 
-    const out: any = {}
+    const out: Record<string, unknown> = {};
     for (const [key, value] of Object.entries(projection)) {
         out[key] = runProjection(value, vars);
     }

package/src/dsl/setup/ActivityContext.test.ts

@@ -1,57 +1,56 @@
-import { ContentEventName, DSLActivityExecutionPayload } from "@vertesia/common";
-import { describe, expect, it } from "vitest";
-import { setupActivity } from "./ActivityContext.js";
+import { ContentEventName, type DSLActivityExecutionPayload } from '@vertesia/common';
+import { describe, expect, it } from 'vitest';
+import { setupActivity } from './ActivityContext.js';
 
 const MOCK_AUTH_TOKEN =
-    "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwOi8vbW9jay10b2tlbi1zZXJ2ZXIiLCJzdWIiOiJ0ZXN0In0.signature";
+    'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwOi8vbW9jay10b2tlbi1zZXJ2ZXIiLCJzdWIiOiJ0ZXN0In0.signature';
 
-function basePayload<T extends Record<string, any>>(
-    activity: DSLActivityExecutionPayload<T>["activity"],
+function basePayload<T extends object>(
+    activity: DSLActivityExecutionPayload<T>['activity'],
     params: T,
 ): DSLActivityExecutionPayload<T> {
     return {
         event: ContentEventName.create,
         vars: {},
-        account_id: "acc",
-        project_id: "prj",
+        account_id: 'acc',
+        project_id: 'prj',
         auth_token: MOCK_AUTH_TOKEN,
-        config: { studio_url: "http://localhost", store_url: "http://localhost" },
+        config: { studio_url: 'http://localhost', store_url: 'http://localhost' },
         activity,
         params,
-        workflow_name: "test",
+        workflow_name: 'test',
     };
 }
 
-describe("setupActivity", () => {
+describe('setupActivity', () => {
     // Regression guard: user-supplied strings containing "${...}" must be preserved
     // verbatim when the activity is dispatched from TypeScript code (no activity.params,
     // no activity.fetch). Previously Vars.parse/resolve would treat any "${...}" as a
     // template ref and silently drop the key when it failed to resolve.
-    it("preserves user data containing literal ${} in code-dispatched activities", async () => {
+    it('should preserve user data containing literal ${} in code-dispatched activities', async () => {
         const data = {
             task: 'preserve "${}" literal',
-            other: "also has ${undefined_ref}",
+            other: 'also has ${undefined_ref}',
         };
-        const payload = basePayload({ name: "testActivity" }, { data });
+        const payload = basePayload({ name: 'testActivity' }, { data });
         const ctx = await setupActivity(payload);
         expect(ctx.params.data.task).toBe('preserve "${}" literal');
-        expect(ctx.params.data.other).toBe("also has ${undefined_ref}");
+        expect(ctx.params.data.other).toBe('also has ${undefined_ref}');
     });
 
-    it("returns empty params when code-dispatched activity has no params", async () => {
-        const payload = basePayload({ name: "testActivity" }, undefined as any);
+    it('should return empty params when code-dispatched activity has no params', async () => {
+        const payload = basePayload({ name: 'testActivity' }, undefined as unknown as Record<string, unknown>);
         const ctx = await setupActivity(payload);
         expect(ctx.params).toEqual({});
     });
 
     // Counter-test: DSL-defined activities (those carrying activity.params) must
     // still have their ${refs} resolved against payload.params (imported vars).
-    it("still resolves ${refs} in activity.params for DSL-dispatched activities", async () => {
-        const payload = basePayload(
-            { name: "dslActivity", params: { message: "Hello ${name}" } },
-            { name: "World" } as any,
-        );
+    it('should still resolve ${refs} in activity.params for DSL-dispatched activities', async () => {
+        const payload = basePayload({ name: 'dslActivity', params: { message: 'Hello ${name}' } }, {
+            name: 'World',
+        } as unknown as Record<string, unknown>);
         const ctx = await setupActivity(payload);
-        expect((ctx.params as any).message).toBe("Hello World");
+        expect((ctx.params as { message: string }).message).toBe('Hello World');
     });
 });