agentlang 0.0.56 → 0.0.58

package/src/runtime/module.ts

@@ -47,6 +47,7 @@ import { parseStatement } from '../language/parser.js';
 import { ActiveSessionInfo, AdminSession } from './auth/defs.js';
 import { FetchModuleFn, PathAttributeName } from './defs.js';
 import { logger } from './logger.js';
+import { FlowStepPattern } from '../language/syntax.js';
 
 export class ModuleEntry {
   name: string;
@@ -1316,6 +1317,13 @@ export class Workflow extends ModuleEntry {
   }
 }
 
+export type FlowGraphNode = {
+  label: string;
+  type: 'action' | 'condition';
+  on?: string[] | undefined;
+  next: string[];
+};
+
 export class Flow extends ModuleEntry {
   flowSteps: string[];
 
@@ -1344,10 +1352,47 @@ export class Flow extends ModuleEntry {
     return this;
   }
 
+  appendStep(s: string): Flow {
+    this.flowSteps.push(s);
+    return this;
+  }
+
   stepsCount(): number {
     return this.flowSteps.length;
   }
 
+  toGraph(): FlowGraphNode[] {
+    const result = new Array<FlowGraphNode>();
+    this.flowSteps.forEach((s: string) => {
+      const fp = FlowStepPattern.Parse(s);
+      if (fp.condition) {
+        const orig = result.find((v: FlowGraphNode) => {
+          return v.label == fp.first;
+        });
+        if (orig) {
+          const nxs = orig.next;
+          nxs?.push(fp.next);
+          const conds = orig.on;
+          conds?.push(fp.condition);
+        } else {
+          result.push({
+            label: fp.first,
+            type: 'condition',
+            on: [fp.condition],
+            next: [fp.next],
+          });
+        }
+      } else {
+        result.push({
+          label: fp.first,
+          type: 'action',
+          next: [fp.next],
+        });
+      }
+    });
+    return result;
+  }
+
   override toString(): string {
     return `flow ${this.name} {
       ${this.getFlow()}
@@ -1355,6 +1400,40 @@ export class Flow extends ModuleEntry {
   }
 }
 
+export function flowGraphNext(
+  graph: FlowGraphNode[],
+  currentNode?: FlowGraphNode,
+  onCondition?: string
+): FlowGraphNode | undefined {
+  if (!currentNode) {
+    return graph[0];
+  }
+  const node = graph.find((n: FlowGraphNode) => {
+    return n.label == currentNode.label;
+  });
+  if (node) {
+    if (onCondition) {
+      const c = node.on?.findIndex((v: string) => {
+        return v == onCondition;
+      });
+      if (c != undefined) {
+        const next = node.next[c];
+        const r = graph.find((n: FlowGraphNode) => {
+          return n.label == next;
+        });
+        return r || { label: next, type: 'action', next: [] };
+      } else {
+        return undefined;
+      }
+    } else {
+      return graph.find((n: FlowGraphNode) => {
+        return n.label == node.next[0];
+      });
+    }
+  }
+  return undefined;
+}
+
 class StandaloneStatement extends ModuleEntry {
   stmt: Statement;
 
@@ -1378,17 +1457,14 @@ export function isEmptyWorkflow(wf: Workflow): boolean {
 export class Module {
   name: string;
   entries: ModuleEntry[];
-  entriesByTypeCache: Map<RecordType, ModuleEntry[]> | null;
 
   constructor(name: string) {
     this.name = name;
     this.entries = new Array<ModuleEntry>();
-    this.entriesByTypeCache = null;
   }
 
   addEntry(entry: ModuleEntry): ModuleEntry {
     this.entries.push(entry);
-    if (this.entriesByTypeCache != null) this.entriesByTypeCache = null;
     return entry;
   }
 
@@ -1427,6 +1503,19 @@ export class Module {
     return undefined;
   }
 
+  getAllFlows(): Flow[] {
+    return this.entries.filter((v: ModuleEntry) => {
+      return v instanceof Flow;
+    });
+  }
+
+  removeFlow(name: string): boolean {
+    if (this.getFlow(name)) {
+      return this.removeEntry(name);
+    }
+    return false;
+  }
+
   addStandaloneStatement(stmt: Statement): StandaloneStatement {
     const s = new StandaloneStatement(stmt, this.name);
     this.addEntry(s);
@@ -1468,27 +1557,16 @@ export class Module {
     const idx: number = this.getEntryIndex(entryName);
     if (idx >= 0) {
       this.entries.splice(idx, 1);
-      if (this.entriesByTypeCache != null) this.entriesByTypeCache = null;
       return true;
     }
     return false;
   }
 
   private getEntriesOfType(t: RecordType): ModuleEntry[] {
-    if (this.entriesByTypeCache != null && this.entriesByTypeCache.has(t)) {
-      const result: ModuleEntry[] | undefined = this.entriesByTypeCache.get(t);
-      if (result == undefined) return new Array<ModuleEntry>();
-      return result;
-    } else {
-      const result: ModuleEntry[] = this.entries.filter((v: ModuleEntry) => {
-        const r: Record = v as Record;
-        return r.type == t;
-      });
-      if (this.entriesByTypeCache != null)
-        this.entriesByTypeCache = new Map<RecordType, ModuleEntry[]>();
-      this.entriesByTypeCache?.set(t, result);
-      return result;
-    }
+    return this.entries.filter((v: ModuleEntry) => {
+      const r: Record = v as Record;
+      return r.type == t;
+    });
   }
 
   getEntityEntries(): Entity[] {
@@ -2142,9 +2220,14 @@ export function parsePrePostWorkflowName(name: string): ThinWfHeader {
 }
 
 function getEntityDef(entityName: string, moduleName: string): Entity | undefined {
-  const parts = splitFqName(entityName);
-  const mname = parts.hasModule() ? parts.getModuleName() : moduleName;
-  return getEntity(parts.getEntryName(), mname);
+  try {
+    const parts = splitFqName(entityName);
+    const mname = parts.hasModule() ? parts.getModuleName() : moduleName;
+    return getEntity(parts.getEntryName(), mname);
+  } catch (reason: any) {
+    logger.error(`getEntityDef: ${reason}`);
+  }
+  return undefined;
 }
 
 export function getWorkflow(eventInstance: Instance): Workflow {

package/src/runtime/util.ts

@@ -516,3 +516,14 @@ export function fileExtension(fileName: string): string {
   }
   return '';
 }
+
+export function trimQuotes(s: string): string {
+  let ss = s.trim();
+  if (ss[0] == '"') {
+    ss = ss.substring(1);
+  }
+  if (ss[ss.length - 1] == '"') {
+    return ss.substring(0, ss.length - 1);
+  }
+  return ss;
+}