@vertesia/workflow 0.42.2

package/src/dsl/projections.test.ts

@@ -0,0 +1,159 @@
+import { describe, test, expect } from "vitest";
+import { Vars } from "./vars.ts";
+import { makeProjection } from "./projections.ts";
+
+describe('Result Projections', () => {
+
+    test('simple projection', () => {
+        const params: Record<string, any> = {
+            docTypes: [{ id: 1, name: "type1" }, { id: 2, name: "type2" }],
+            objectId: "123"
+        }
+        const result = {
+            result: {
+                document_type: "C",
+            }
+        }
+        const spec = {
+            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.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"
+        }
+        const result = {
+            result: {
+                document_type: "type2",
+            }
+        }
+        const spec = {
+            docType: {
+                $element: {
+                    from: "${docTypes}",
+                    where: { name: { $eq: "${#.result.document_type}" } },
+                    else: { id: 0, name: "unknown" }
+                }
+            },
+            isNewType: {
+                $eval: {
+                    "#.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.isNewType).toBe(false);
+    })
+
+    test('$element does not match', () => {
+        const params: Record<string, any> = {
+            docTypes: [{ id: 1, name: "type1" }, { id: 2, name: "type2" }],
+            objectId: "123"
+        }
+        const result = {
+            result: {
+                document_type: "a_new_type",
+            }
+        }
+        const projection = {
+            docType: {
+                $element: {
+                    from: "${docTypes}",
+                    where: { name: { $eq: "${#.result.document_type}" } },
+                    else: { id: 0, name: "${#.result.document_type}" }
+                }
+            },
+            isNewType: {
+                $eval: {
+                    "#.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.isNewType).toBe(true);
+    })
+
+    test('$element with field', () => {
+        const params: Record<string, any> = {
+            docTypes: [{ id: 1, name: "type1" }, { id: 2, name: "type2" }],
+            objectId: "123"
+        }
+        const result = {
+            result: {
+                document_type: "type2",
+            }
+        }
+        const projection = {
+            other: null,
+            name: "${#.result.document_type}",
+            id: {
+                $element: {
+                    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"
+        }
+        const result = {
+            result: {
+                document_type: "a_new_type",
+            }
+        }
+        const projection = {
+            other: null,
+            name: "${#.result.document_type}",
+            id: {
+                $element: {
+                    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 });
+    })
+
+});

package/src/dsl/projections.ts

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

package/src/dsl/setup/ActivityContext.ts

@@ -0,0 +1,106 @@
+import { ComposableClient } from "@vertesia/client";
+import { DSLActivityExecutionPayload, DSLWorkflowExecutionPayload, Project, WorkflowExecutionPayload } from "@vertesia/common";
+import { log } from "@temporalio/activity";
+import { NoDocumentFound, WorkflowParamNotFound } from "../../errors.js";
+import { getClient } from "../../utils/client.js";
+import { Vars } from "../vars.js";
+import { getFetchProvider, registerFetchProviderFactory } from "./fetch/index.js";
+import { DocumentProvider, DocumentTypeProvider, InteractionRunProvider } from "./fetch/providers.js";
+import { getProjectFromToken } from "../../utils/auth.js";
+
+
+registerFetchProviderFactory(DocumentProvider.ID, DocumentProvider.factory);
+registerFetchProviderFactory(DocumentTypeProvider.ID, DocumentTypeProvider.factory);
+registerFetchProviderFactory(InteractionRunProvider.ID, InteractionRunProvider.factory);
+
+export class ActivityContext<T extends Record<string, any> = Record<string, any>> {
+    client: ComposableClient;
+    _project?: Promise<Project | undefined>;
+
+    constructor(public payload: DSLActivityExecutionPayload, client: ComposableClient, public params: T) {
+        this.client = client;
+        this.fetchProject = this.fetchProject.bind(this);
+    }
+
+    get objectIds() {
+        return this.payload.objectIds;
+    }
+
+    get objectId() {
+        const objectId = this.payload.objectIds && this.payload.objectIds[0];
+        if (!objectId) {
+            log.error('No objectId found in payload');
+            throw new WorkflowParamNotFound('objectIds[0]', (this.payload as WorkflowExecutionPayload as DSLWorkflowExecutionPayload).workflow);
+        }
+        return objectId;
+    }
+
+    fetchProject() {
+        if (!this._project) {
+            this._project = _fetchProject(this.client, this.payload);
+        }
+        return this._project;
+    }
+
+}
+
+
+export async function setupActivity<T extends Record<string, any> = Record<string, any>>(payload: DSLActivityExecutionPayload) {
+
+    const isDebugMode = !!payload.debug_mode;
+
+    const vars = new Vars({
+        ...payload.params, // imported params (doesn't contain expressions)
+        ...payload.activity.params, // activity params (may contain expressions)
+    });
+
+    //}
+    if (isDebugMode) {
+        log.info(`Setting up activity ${payload.activity.name}`, { config: payload.config, activity: payload.activity, params: payload.params, vars });
+    }
+
+    const client = getClient(payload);
+    const fetchSpecs = payload.activity.fetch;
+    if (fetchSpecs) {
+
+        const keys = Object.keys(fetchSpecs);
+        if (keys.length > 0) {
+            // create a new Vars instance to store the fetched data
+            for (const key of keys) {
+                let fetchSpec = fetchSpecs[key];
+                let query = fetchSpec.query;
+                if (query) {
+                    query = vars.resolveParams(query);
+                    fetchSpec = { ...fetchSpec, query };
+                }
+
+                const provider = await getFetchProvider(client, 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) {
+                        vars.setValue(key, result[0]);
+                    } else {
+                        vars.setValue(key, result);
+                    }
+                } else if (fetchSpec.on_not_found === 'throw') {
+                    throw new NoDocumentFound("No documents found for: " + JSON.stringify(fetchSpec));
+                } else {
+                    vars.setValue(key, null);
+                }
+            }
+        }
+    }
+
+    const params = vars.resolve() as T;
+    log.info(`Activity ${payload.activity.name} setup complete`, { params });
+
+    return new ActivityContext<T>(payload, client, params);
+}
+
+
+async function _fetchProject(client: ComposableClient, 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

@@ -0,0 +1,45 @@
+import { 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("-")) {
+            result[part.substring(1)] = 0;
+        } else {
+            result[part] = 1;
+        }
+    }
+    return result;
+}
+
+function applyProjection(result: Record<string, any>, select: string) {
+    if (!result) return result;
+    let selectorObj: Record<string, number | boolean>;
+    if (typeof select === 'string') {
+        selectorObj = parseSelector(select);
+    } else {
+        selectorObj = select;
+    }
+
+    const out: Record<string, any> = {};
+    for (const key of Object.keys(result)) {
+        if (selectorObj[key]) {
+            out[key] = result[key];
+        }
+    }
+    return out;
+}
+
+export abstract class DataProvider {
+    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!));
+        }
+        return results;
+    }
+    abstract doFetch(payload: FindPayload): Promise<Record<string, any>[]>;
+}

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

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

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

@@ -0,0 +1,67 @@
+import { FindPayload } from "@vertesia/common";
+import { ComposableClient } from "@vertesia/client";
+import { DataProvider } from "./DataProvider.js";
+
+function useMongoId(query: Record<string, any>) {
+    if (query.id) {
+        const result = { ...query, _id: query.id }
+        delete (result as any).id;
+        return result;
+    }
+    return query;
+}
+
+export class DocumentProvider extends DataProvider {
+    static ID = "document";
+    constructor(public client: ComposableClient) {
+        super(DocumentProvider.ID, true);
+    }
+
+    doFetch(payload: FindPayload): Promise<Record<string, any>[]> {
+        const query = useMongoId(payload.query);
+        return this.client.objects.find({
+            query, select: payload.select, limit: payload.limit
+        });
+    }
+
+    static factory(client: ComposableClient) {
+        return new DocumentProvider(client);
+    }
+}
+
+export class DocumentTypeProvider extends DataProvider {
+    static ID = "document_type";
+    constructor(public client: ComposableClient) {
+        super(DocumentTypeProvider.ID, true);
+    }
+
+    doFetch(payload: FindPayload): Promise<Record<string, any>[]> {
+        const query = useMongoId(payload.query);
+        return this.client.types.find({
+            query, select: payload.select, limit: payload.limit
+        });
+    }
+
+    static factory(client: ComposableClient) {
+        return new DocumentTypeProvider(client);
+    }
+}
+
+export class InteractionRunProvider extends DataProvider {
+    static ID = "interaction_run";
+    constructor(public client: ComposableClient) {
+        super(DocumentProvider.ID, true);
+    }
+
+    doFetch(payload: FindPayload): Promise<Record<string, any>[]> {
+        const query = useMongoId(payload.query);
+        return this.client.runs.find({
+            query, select: payload.select, limit: payload.limit
+        });
+    }
+
+    static factory(client: ComposableClient) {
+        return new InteractionRunProvider(client);
+    }
+
+}

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

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