@vertesia/workflow 0.24.0-dev.202601221707

package/src/dsl/walk.ts

@@ -0,0 +1,103 @@
+
+export type ObjectKey = string | number | undefined;
+export interface ObjectVisitor {
+    onStartObject?: (key: ObjectKey, value: any) => void;
+    onEndObject?: (key: ObjectKey, value: any) => void;
+    onStartIteration?: (key: ObjectKey, value: Iterable<any>) => void;
+    onEndIteration?: (key: ObjectKey, value: Iterable<any>) => void;
+    onValue?: (key: ObjectKey, value: any) => void;
+}
+
+export class ObjectWalker {
+    supportIterators = false; // only array are supported by default
+    constructor(supportIterators = false) {
+        this.supportIterators = supportIterators;
+    }
+    walk(obj: any, visitor: ObjectVisitor) {
+        this._walk(undefined, obj, visitor);
+    }
+    _walk(key: ObjectKey, obj: any, visitor: ObjectVisitor) {
+        const type = typeof obj;
+        if (!obj || type !== 'object' || obj instanceof Date) {
+            visitor.onValue && visitor.onValue(key, obj);
+        } else if (Array.isArray(obj)) {
+            this._walkIterable(key, obj, visitor);
+        } else if (this.supportIterators && obj[Symbol.iterator] === 'function') {
+            this._walkIterable(key, obj, visitor);
+        } else if (obj.constructor === Object) { // a plain object
+            this._walkObject(key, obj, visitor);
+        } else { // a random object - we treat it as a value
+            visitor.onValue && visitor.onValue(key, obj);
+        }
+    }
+
+    _walkIterable(key: ObjectKey, obj: any, visitor: ObjectVisitor) {
+        visitor.onStartIteration && visitor.onStartIteration(key, obj);
+        let i = 0;
+        for (const value of obj) {
+            this._walk(i++, value, visitor);
+        }
+        visitor.onEndIteration && visitor.onEndIteration(key, obj);
+    }
+
+    _walkObject(key: ObjectKey, obj: any, visitor: ObjectVisitor) {
+        visitor.onStartObject && visitor.onStartObject(key, obj);
+        for (const k of Object.keys(obj)) {
+            this._walk(k, obj[k], visitor);
+        }
+        visitor.onEndObject && visitor.onEndObject(key, obj);
+    }
+
+    map(obj: any, mapFn: (key: ObjectKey, value: any) => any) {
+        const visitor = new MapVisitor(mapFn);
+        this.walk(obj, visitor);
+        return visitor.result;
+    }
+}
+
+class MapVisitor implements ObjectVisitor {
+    result: any;
+    current: any;
+    stack: any[] = [];
+    constructor(private mapFn: (key: ObjectKey, value: any) => any) { }
+
+    onStartObject(key: ObjectKey) {
+        if (key === undefined) {
+            this.result = {};
+            this.current = this.result;
+        } else {
+            this.stack.push(this.current);
+            const obj = {};
+            this.current[key] = obj;
+            this.current = obj;
+        }
+    }
+    onEndObject() {
+        this.current = this.stack.pop();
+    }
+
+    onStartIteration(key: ObjectKey) {
+        if (key === undefined) {
+            this.result = [];
+            this.current = this.result;
+        } else {
+            this.stack.push(this.current);
+            const ar: any[] = [];
+            this.current[key] = ar;
+            this.current = ar;
+        }
+    }
+
+    onEndIteration() {
+        this.current = this.stack.pop();
+    }
+
+    onValue(key: ObjectKey, value: any) {
+        const r = this.mapFn(key, value);
+        if (key === undefined) {
+            this.result = r;
+        } else if (r !== undefined) {
+            this.current[key] = r;
+        }
+    }
+}

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

@@ -0,0 +1,273 @@
+import * as protos from '@temporalio/proto';
+import { TestWorkflowEnvironment } from '@temporalio/testing';
+import { Worker } from '@temporalio/worker';
+import { ContentEventName, DSLActivityExecutionPayload, DSLWorkflowExecutionPayload, DSLWorkflowStep } from '@vertesia/common';
+import { afterAll, beforeAll, describe, expect, test } from 'vitest';
+import { dslWorkflow } from './dsl-workflow.js';
+import { setupActivity } from './setup/ActivityContext.js';
+
+interface SayHelloParams {
+    name: string;
+}
+interface PrepareResultParams {
+    parent: string;
+    child: string;
+}
+
+async function sayHelloFromParent(payload: DSLActivityExecutionPayload<SayHelloParams>) {
+    const { params } = await setupActivity(payload);
+    return `Parent: Hello, ${params.name}!`;
+}
+
+async function sayHelloFromDSLChild(payload: DSLActivityExecutionPayload<SayHelloParams>) {
+    const { params } = await setupActivity(payload);
+    return `DSL Child: Hello, ${params.name}!`;
+}
+
+async function prepareResult(payload: DSLActivityExecutionPayload<PrepareResultParams>) {
+    const { params } = await setupActivity(payload);
+    return [params.parent, params.child]
+}
+
+const steps1: DSLWorkflowStep[] = [
+    {
+        type: 'activity',
+        name: 'sayHelloFromParent',
+        output: 'parent',
+        import: ["name"],
+    },
+    {
+        type: 'workflow',
+        name: 'testChildWorkflow',
+        output: 'child',
+    },
+    {
+        type: 'activity',
+        name: 'prepareResult',
+        import: ["parent", "child"],
+        output: 'result',
+    }
+]
+
+const childSteps: DSLWorkflowStep[] = [
+    {
+        type: 'activity',
+        name: 'sayHelloFromDSLChild',
+        output: 'result',
+        import: ["name"],
+    },
+]
+
+const steps2: DSLWorkflowStep[] = [
+    {
+        type: 'activity',
+        name: 'sayHelloFromParent',
+        output: 'parent',
+        import: ["name"],
+    },
+    {
+        type: 'workflow',
+        name: 'dslWorkflow',
+        output: 'child',
+        spec: {
+            name: 'testChildWorkflow',
+            steps: childSteps,
+            vars: {}
+        }
+    },
+    {
+        type: 'activity',
+        name: 'prepareResult',
+        import: ["parent", "child"],
+        output: 'result',
+    }
+]
+
+const steps3: DSLWorkflowStep[] = [
+    {
+        type: 'activity',
+        name: 'sayHelloFromParent',
+        output: 'parent',
+        import: ["name"],
+    },
+    {
+        type: 'workflow',
+        name: 'dslWorkflow',
+        output: 'child',
+        spec: {
+            name: 'testChildWorkflow',
+            steps: childSteps,
+            vars: {}
+        },
+        vars: {
+            storeUrl: 'store:${objectIds[0]}',
+            name: '${name}'
+        }
+    },
+    {
+        type: 'activity',
+        name: 'prepareResult',
+        import: ["parent", "child"],
+        output: 'result',
+    }
+]
+
+
+// ========== test env setup ==========
+
+
+describe('DSL Workflow with child workflows', () => {
+
+    let testEnv: TestWorkflowEnvironment;
+
+    beforeAll(async () => {
+        testEnv = await TestWorkflowEnvironment.createLocal();
+        const { connection } = testEnv;
+        await connection.operatorService.addSearchAttributes({
+            namespace: 'default',
+            searchAttributes: {
+                AccountId: protos.temporal.api.enums.v1.IndexedValueType.INDEXED_VALUE_TYPE_KEYWORD,
+                DocumentId: protos.temporal.api.enums.v1.IndexedValueType.INDEXED_VALUE_TYPE_KEYWORD,
+                ProjectId: protos.temporal.api.enums.v1.IndexedValueType.INDEXED_VALUE_TYPE_KEYWORD,
+                TenantId: protos.temporal.api.enums.v1.IndexedValueType.INDEXED_VALUE_TYPE_KEYWORD,
+                InitiatedBy: protos.temporal.api.enums.v1.IndexedValueType.INDEXED_VALUE_TYPE_KEYWORD,
+            },
+        });
+    });
+
+    afterAll(async () => {
+        await testEnv?.teardown();
+    });
+
+    test('execute child workflow', async () => {
+        const { client, nativeConnection } = testEnv;
+        const taskQueue = 'test';
+
+        const name = 'Foo';
+
+        const worker = await Worker.create({
+            connection: nativeConnection,
+            taskQueue,
+            workflowsPath: new URL("./test/test-child-workflow.ts", import.meta.url).pathname,
+            activities: { sayHelloFromParent, prepareResult },
+        });
+
+        const payload: DSLWorkflowExecutionPayload = {
+            event: ContentEventName.create,
+            objectIds: ['123'],
+            vars: {},
+            account_id: '123',
+            project_id: '123',
+            wf_rule_name: 'test',
+            auth_token: process.env.VERTESIA_KEY || 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwOi8vbW9jay10b2tlbi1zZXJ2ZXIiLCJzdWIiOiJ0ZXN0In0.signature',
+            config: {
+                studio_url: process.env.CP_STUDIO_URL || "http://localhost:8081",
+                store_url: process.env.CP_STORE_URL || "http://localhost:8082",
+            },
+            workflow: {
+                steps: steps1,
+                vars: {
+                    name,
+                },
+                name: 'test',
+            }
+        }
+
+        let result = await worker.runUntil(client.workflow.execute(dslWorkflow, {
+            args: [payload],
+            workflowId: 'test',
+            taskQueue,
+        }));
+
+        expect(result).toEqual([`Parent: Hello, ${name}!`, `Child: Hello, ${name}!`]);
+
+    });
+
+    test('execute DSL child workflow', async () => {
+        const { client, nativeConnection } = testEnv;
+        const taskQueue = 'test';
+
+        const name = 'Bar';
+
+        const worker = await Worker.create({
+            connection: nativeConnection,
+            taskQueue,
+            workflowsPath: new URL("./test/test-child-workflow.ts", import.meta.url).pathname,
+            activities: { sayHelloFromParent, prepareResult, sayHelloFromDSLChild },
+        });
+
+        const payload: DSLWorkflowExecutionPayload = {
+            event: ContentEventName.create,
+            objectIds: ['123'],
+            vars: {},
+            account_id: '123',
+            project_id: '123',
+            wf_rule_name: 'test',
+            auth_token: process.env.VERTESIA_KEY || 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwOi8vbW9jay10b2tlbi1zZXJ2ZXIiLCJzdWIiOiJ0ZXN0In0.signature',
+            config: {
+                studio_url: process.env.CP_STUDIO_URL || "http://localhost:8081",
+                store_url: process.env.CP_STORE_URL || "http://localhost:8082",
+            },
+            workflow: {
+                steps: steps2,
+                vars: {
+                    name,
+                },
+                name: 'test',
+            }
+        }
+
+        let result = await worker.runUntil(client.workflow.execute(dslWorkflow, {
+            args: [payload],
+            workflowId: 'test',
+            taskQueue,
+        }));
+
+        expect(result).toEqual([`Parent: Hello, ${name}!`, `DSL Child: Hello, ${name}!`]);
+
+    });
+
+    test('execute DSL child workflow with variable resolution', async () => {
+        const { client, nativeConnection } = testEnv;
+        const taskQueue = 'test';
+
+        const name = 'Baz';
+
+        const worker = await Worker.create({
+            connection: nativeConnection,
+            taskQueue,
+            workflowsPath: new URL("./test/test-child-workflow.ts", import.meta.url).pathname,
+            activities: { sayHelloFromParent, prepareResult, sayHelloFromDSLChild },
+        });
+
+        const payload: DSLWorkflowExecutionPayload = {
+            event: ContentEventName.create,
+            objectIds: ['doc123'],
+            vars: {},
+            account_id: '123',
+            project_id: '123',
+            wf_rule_name: 'test',
+            auth_token: process.env.VERTESIA_KEY || 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwOi8vbW9jay10b2tlbi1zZXJ2ZXIiLCJzdWIiOiJ0ZXN0In0.signature',
+            config: {
+                studio_url: process.env.CP_STUDIO_URL || "http://localhost:8081",
+                store_url: process.env.CP_STORE_URL || "http://localhost:8082",
+            },
+            workflow: {
+                steps: steps3,
+                vars: {
+                    name,
+                },
+                name: 'test',
+            }
+        }
+
+        let result = await worker.runUntil(client.workflow.execute(dslWorkflow, {
+            args: [payload],
+            workflowId: 'test-vars',
+            taskQueue,
+        }));
+
+        expect(result).toEqual([`Parent: Hello, ${name}!`, `DSL Child: Hello, ${name}!`]);
+
+    });
+});

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

@@ -0,0 +1,138 @@
+import { VertesiaClient } from '@vertesia/client';
+import { ContentEventName, DSLActivityExecutionPayload, DSLActivitySpec, DSLWorkflowExecutionPayload, FindPayload } from '@vertesia/common';
+import { TestWorkflowEnvironment } from '@temporalio/testing';
+import { Worker } from '@temporalio/worker';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { dslWorkflow } from './dsl-workflow.js';
+import { setupActivity } from "./setup/ActivityContext.js";
+import { DataProvider } from './setup/fetch/DataProvider.js';
+import { registerFetchProviderFactory } from './setup/fetch/index.js';
+
+interface SayMessageParams {
+    message: string;
+}
+
+class DocumentTestProvider extends DataProvider {
+
+    static ID = "document";
+
+    constructor() {
+        super(DocumentTestProvider.ID, true);
+    }
+
+    doFetch(payload: FindPayload): Promise<Record<string, any>[]> {
+        const query = payload.query;
+        console.log('query', query);
+        if (query.lang === 'en') {
+            return Promise.resolve([query.greeting ? { text: 'Hello' } : { text: "World" }])
+        } else {
+            return Promise.resolve([query.greeting ? { text: 'Bonjour' } : { text: "Monde" }])
+        }
+    }
+
+    static factory(_context: VertesiaClient) {
+        return new DocumentTestProvider();
+    }
+}
+
+registerFetchProviderFactory(DocumentTestProvider.ID, DocumentTestProvider.factory);
+
+
+async function sayMessage(payload: DSLActivityExecutionPayload<SayMessageParams>): Promise<string> {
+    const { params } = await setupActivity(payload);
+    return params.message;
+}
+
+
+const activities: DSLActivitySpec[] = [
+    {
+        name: 'sayMessage',
+        output: 'result',
+        import: ["lang"],
+        params: {
+            message: "${greeting.text}, ${name.text}!"
+        },
+        fetch: {
+            name: {
+                type: "document",
+                query: {
+                    lang: "${lang}", greeting: false
+                },
+                limit: 1,
+            },
+            greeting: {
+                type: "document",
+                query: {
+                    lang: "${lang}", greeting: true
+                },
+                limit: 1,
+            }
+        },
+    },
+]
+
+// ========== test env setup ==========
+
+
+describe('DSL Workflow', () => {
+
+    let testEnv: TestWorkflowEnvironment;
+
+    beforeAll(async () => {
+        testEnv = await TestWorkflowEnvironment.createLocal();
+    });
+
+    afterAll(async () => {
+        await testEnv?.teardown();
+    });
+
+    it('successfully completes a mock workflow', async () => {
+        const { client, nativeConnection } = testEnv;
+        const taskQueue = 'test';
+
+        const lang = 'en';
+
+        const worker = await Worker.create({
+            connection: nativeConnection,
+            taskQueue,
+            workflowsPath: new URL("./dsl-workflow.ts", import.meta.url).pathname,
+            activities: { sayMessage },
+        });
+
+        const payload: DSLWorkflowExecutionPayload = {
+            event: ContentEventName.create,
+            objectIds: ['123'],
+            vars: {},
+            account_id: '123',
+            project_id: '123',
+            timestamp: Date.now(),
+            wf_rule_name: 'test',
+            auth_token: process.env.VERTESIA_KEY || 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwOi8vbW9jay10b2tlbi1zZXJ2ZXIiLCJzdWIiOiJ0ZXN0In0.signature',
+            config: {
+                studio_url: process.env.CP_STUDIO_URL || "http://localhost:8081",
+                store_url: process.env.CP_STORE_URL || "http://localhost:8082",
+            },
+            workflow: {
+                activities,
+                vars: {
+                    lang,
+                },
+                name: 'test',
+            }
+        }
+
+        let result = await worker.runUntil(client.workflow.execute(dslWorkflow, {
+            args: [payload],
+            workflowId: 'test',
+            taskQueue,
+        }));
+
+        expect(result).toBe('Hello, World!');
+
+    });
+
+
+
+
+
+});

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

@@ -0,0 +1,89 @@
+import { ContentEventName, DSLActivityExecutionPayload, DSLActivitySpec, DSLWorkflowExecutionPayload } from '@vertesia/common';
+import { TestWorkflowEnvironment } from '@temporalio/testing';
+import { Worker } from '@temporalio/worker';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { dslWorkflow } from './dsl-workflow.js';
+import { setupActivity } from "./setup/ActivityContext.js";
+
+
+async function testImportedVars(payload: DSLActivityExecutionPayload) {
+    const { params } = await setupActivity(payload);
+    if (!params.object_name) throw new Error('object_name is required');
+    console.log('!!!!!!!!!!@@@@@@@@@@@@@@!!!!!!!!!!!!!!', params.object_name);
+    return params.object_name;
+}
+
+
+const activities: DSLActivitySpec[] = [
+    {
+        name: 'testImportedVars',
+        import: ["object_name"],
+        output: 'result',
+    },
+]
+
+// ========== test env setup ==========
+
+
+describe('DSL Workflow import vars', () => {
+
+    let testEnv: TestWorkflowEnvironment;
+
+    beforeAll(async () => {
+        testEnv = await TestWorkflowEnvironment.createLocal();
+    });
+
+    afterAll(async () => {
+        await testEnv?.teardown();
+    });
+
+
+    it('import vars are part of activity params', async () => {
+
+
+        const { client, nativeConnection } = testEnv;
+        const taskQueue = 'test';
+
+        const object_name = 'object_name';
+
+        const worker = await Worker.create({
+            connection: nativeConnection,
+            taskQueue,
+            workflowsPath: new URL("./dsl-workflow.ts", import.meta.url).pathname,
+            activities: { testImportedVars },
+        });
+
+        const payload: DSLWorkflowExecutionPayload = {
+            event: ContentEventName.create,
+            objectIds: ['123'],
+            vars: {},
+            account_id: '123',
+            project_id: '123',
+            timestamp: Date.now(),
+            wf_rule_name: 'test',
+            auth_token: process.env.VERTESIA_KEY || 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwOi8vbW9jay10b2tlbi1zZXJ2ZXIiLCJzdWIiOiJ0ZXN0In0.signature',
+            config: {
+                studio_url: process.env.CP_STUDIO_URL || "http://localhost:8081",
+                store_url: process.env.CP_STORE_URL || "http://localhost:8082",
+            },
+            workflow: {
+                activities,
+                vars: {
+                    object_name,
+                },
+                name: 'test',
+            }
+        }
+
+        let result = await worker.runUntil(client.workflow.execute(dslWorkflow, {
+            args: [payload],
+            workflowId: 'test',
+            taskQueue,
+        }));
+
+        expect(result).toBe(object_name);
+
+    });
+
+
+});