agentlang 0.0.28 → 0.0.30

package/src/runtime/interpreter.ts

@@ -1740,8 +1740,11 @@ async function runPrePostEvents(
       }
     };
     if (trigInfo.async) {
-      evaluate(eventInst, callback).catch(catchHandler);
+      const newEnv = new Environment('async.prepost.env');
+      newEnv.bind('this', inst);
+      evaluate(eventInst, callback, newEnv).catch(catchHandler);
     } else {
+      env.bind('this', inst);
       await evaluate(eventInst, callback, env).catch(catchHandler);
     }
   }

package/src/runtime/loader.ts

@@ -413,7 +413,7 @@ export function addRelationshipFromDef(
 }
 
 export function addWorkflowFromDef(def: WorkflowDefinition, moduleName: string): Workflow {
-  return addWorkflow(def.name, moduleName, def.statements, def.hints);
+  return addWorkflow(def.name || '', moduleName, def.statements, def.header);
 }
 
 const StandaloneStatements = new Map<string, Statement[]>();

package/src/runtime/logger.ts

@@ -25,8 +25,6 @@ if (isNodeEnv) {
     maxFiles: '7d',
   });
 
-  const consoleTransport = new winston.transports.Console();
-
   logger = winston.createLogger({
     format: winston.format.combine(
       winston.format.timestamp(),
@@ -34,7 +32,7 @@ if (isNodeEnv) {
         return `[${timestamp}] ${level}: ${message}`;
       })
     ),
-    transports: [fileTransport, consoleTransport],
+    transports: [fileTransport],
   });
 } else {
   function mkLogger(tag: string): Function {

package/src/runtime/module.ts

@@ -19,7 +19,7 @@ import {
   RbacSpecEntry,
   RbacSpecEntries,
   RbacOpr,
-  WorkflowHint,
+  WorkflowHeader,
 } from '../language/generated/ast.js';
 import {
   Path,
@@ -45,7 +45,7 @@ import {
 } from './util.js';
 import { parseStatement } from '../language/parser.js';
 import { ActiveSessionInfo, AdminSession } from './auth/defs.js';
-import { FetchModuleFn, PathAttributeName, SetSubscription } from './defs.js';
+import { FetchModuleFn, PathAttributeName } from './defs.js';
 import { logger } from './logger.js';
 
 export class ModuleEntry {
@@ -1157,10 +1157,17 @@ export class Relationship extends Record {
 
 export class Workflow extends ModuleEntry {
   statements: Statement[];
+  generatedName: boolean;
 
-  constructor(name: string, patterns: Statement[], moduleName: string) {
+  constructor(
+    name: string,
+    patterns: Statement[],
+    moduleName: string,
+    generatedName: boolean = false
+  ) {
     super(name, moduleName);
     this.statements = patterns;
+    this.generatedName = generatedName;
   }
 
   async addStatement(stmtCode: string): Promise<Workflow> {
@@ -1278,7 +1285,8 @@ export class Workflow extends ModuleEntry {
   }
 
   override toString() {
-    let s: string = `workflow ${normalizeWorkflowName(this.name)} {\n`;
+    const n = this.generatedName ? untangleWorkflowName(this.name) : this.name;
+    let s: string = `workflow ${normalizeWorkflowName(n)} {\n`;
     const ss = this.statementsToStringsHelper(this.statements);
     s = s.concat(joinStatements(ss));
     return s.concat('\n}');
@@ -1883,12 +1891,24 @@ function normalizeWorkflowName(n: string): string {
   return n;
 }
 
+export type PrePostTag = '@after' | '@before';
+export type PrePostOpr = 'create' | 'update' | 'delete';
+
+type ThinWfHeader = {
+  tag: PrePostTag;
+  prefix: PrePostOpr;
+  name: string;
+};
+
 export function addWorkflow(
   name: string,
   moduleName = activeModule,
   statements?: Statement[],
-  hints?: WorkflowHint[]
+  hdr?: WorkflowHeader | ThinWfHeader
 ): Workflow {
+  if (hdr) {
+    name = prePostWorkflowName(hdr.tag, hdr.prefix, hdr.name, moduleName);
+  }
   const module: Module = fetchModule(moduleName);
   if (module.hasEntry(name)) {
     const entry: ModuleEntry = module.getEntry(name);
@@ -1900,39 +1920,111 @@ export function addWorkflow(
     event.addMeta(SystemDefinedEvent, 'true');
   }
   if (!statements) statements = new Array<Statement>();
-  if (hints && hints.length > 0) {
+  if (hdr) {
     const eventFqName = makeFqName(moduleName, name);
-    hints.forEach((hint: WorkflowHint) => {
-      if (hint.subs) {
-        SetSubscription(eventFqName, hint.subs.resolverName);
-      } else if (hint.trigs) {
-        if (hint.trigs.after) {
-          hint.trigs.after.triggers.entries.forEach((te: TriggerEntry) => {
-            const entityDef = getEntityDefForTrigger(te, moduleName);
-            entityDef.addAfterTrigger({
-              on: te.on,
-              event: eventFqName,
-              async: te.async ? true : false,
-            });
-          });
-        } else if (hint.trigs.before) {
-          hint.trigs.before.triggers.entries.forEach((te: TriggerEntry) => {
-            const entityDef = getEntityDefForTrigger(te, moduleName);
-            entityDef.addBeforeTrigger({
-              on: te.on,
-              event: eventFqName,
-              async: te.async ? true : false,
-            });
-          });
-        }
-      }
-    });
+    const entityDef = getEntityDef(hdr.name, moduleName);
+    if (hdr.tag == '@after') {
+      entityDef?.addAfterTrigger({
+        on: hdr.prefix,
+        event: eventFqName,
+        async: false,
+      });
+    } else {
+      entityDef?.addBeforeTrigger({
+        on: hdr.prefix,
+        event: eventFqName,
+        async: false,
+      });
+    }
   }
-  return module.addEntry(new Workflow(asWorkflowName(name), statements, moduleName)) as Workflow;
+  return module.addEntry(
+    new Workflow(asWorkflowName(name), statements, moduleName, hdr ? true : false)
+  ) as Workflow;
+}
+
+function addPrePostWorkflow(
+  tag: PrePostTag,
+  opr: PrePostOpr,
+  entityName: string,
+  moduleName = activeModule,
+  statements?: Statement[]
+): Workflow {
+  const hdr: ThinWfHeader = {
+    tag: tag,
+    prefix: opr,
+    name: entityName,
+  };
+  return addWorkflow('', moduleName, statements, hdr);
 }
 
-function getEntityDefForTrigger(te: TriggerEntry, moduleName: string): Entity {
-  const entityName: string = te.event;
+export function addAfterCreateWorkflow(
+  entityName: string,
+  moduleName = activeModule,
+  statements?: Statement[]
+): Workflow {
+  return addPrePostWorkflow('@after', 'create', entityName, moduleName, statements);
+}
+
+export function addAfterUpdateWorkflow(
+  entityName: string,
+  moduleName = activeModule,
+  statements?: Statement[]
+): Workflow {
+  return addPrePostWorkflow('@after', 'update', entityName, moduleName, statements);
+}
+
+export function addAfterDeleteWorkflow(
+  entityName: string,
+  moduleName = activeModule,
+  statements?: Statement[]
+): Workflow {
+  return addPrePostWorkflow('@after', 'delete', entityName, moduleName, statements);
+}
+
+export function addBeforeCreateWorkflow(
+  entityName: string,
+  moduleName = activeModule,
+  statements?: Statement[]
+): Workflow {
+  return addPrePostWorkflow('@before', 'create', entityName, moduleName, statements);
+}
+
+export function addBeforeUpdateWorkflow(
+  entityName: string,
+  moduleName = activeModule,
+  statements?: Statement[]
+): Workflow {
+  return addPrePostWorkflow('@before', 'update', entityName, moduleName, statements);
+}
+
+export function addBeforeDeleteWorkflow(
+  entityName: string,
+  moduleName = activeModule,
+  statements?: Statement[]
+): Workflow {
+  return addPrePostWorkflow('@before', 'delete', entityName, moduleName, statements);
+}
+
+function prePostWorkflowName(
+  tag: PrePostTag,
+  opr: PrePostOpr,
+  entityName: string,
+  moduleName?: string
+): string {
+  const parts = splitFqName(entityName);
+  const mname = parts.hasModule() ? parts.getModuleName() : moduleName;
+  if (!mname) {
+    throw new Error(`Cannot infer module name for ${entityName}`);
+  }
+  return `${tag.substring(1)}_${opr}_${mname}_${parts.getEntryName()}`;
+}
+
+function untangleWorkflowName(name: string): string {
+  const parts = name.split('_');
+  return `@${parts[0]} ${parts[1]}:${parts[2]}/${parts[3]}`;
+}
+
+function getEntityDef(entityName: string, moduleName: string): Entity | undefined {
   const parts = splitFqName(entityName);
   const mname = parts.hasModule() ? parts.getModuleName() : moduleName;
   return getEntity(parts.getEntryName(), mname);
@@ -1949,12 +2041,13 @@ export function getWorkflow(eventInstance: Instance): Workflow {
   return EmptyWorkflow;
 }
 
-export function getEntity(name: string, moduleName: string): Entity {
+export function getEntity(name: string, moduleName: string): Entity | undefined {
   const fr: FetchModuleByEntryNameResult = fetchModuleByEntryName(name, moduleName);
   if (fr.module.isEntity(fr.entryName)) {
     return fr.module.getEntry(fr.entryName) as Entity;
   }
-  throw new Error(`Entity ${fr.entryName} not found in module ${fr.moduleName}`);
+  logger.error(`Entity ${fr.entryName} not found in module ${fr.moduleName}`);
+  return undefined;
 }
 
 function isEntryOfType(t: RecordType, fqName: string): boolean {
@@ -2782,7 +2875,7 @@ export function getEntityRbacRules(entityFqName: string): RbacSpecification[] |
   const m = isModule(mn) && fetchModule(mn);
   if (m && m.isEntity(en)) {
     const entity = getEntity(en, mn);
-    return entity.getRbacSpecifications()?.filter((spec: RbacSpecification) => {
+    return entity?.getRbacSpecifications()?.filter((spec: RbacSpecification) => {
       return spec.expression != undefined;
     });
   }

package/src/syntaxes/agentlang.monarch.ts

@@ -1,7 +1,7 @@
 // Monarch syntax highlighting for the agentlang language.
 export default {
     keywords: [
-        '@actions','@after','@as','@async','@before','@catch','@distinct','@enum','@expr','@from','@into','@meta','@oneof','@rbac','@ref','@subs','@then','@upsert','@with_unique','agent','allow','and','await','between','contains','create','delete','else','entity','error','event','extends','false','for','if','import','in','like','module','not','not_found','onSubscription','or','purge','query','read','record','relationship','resolver','return','roles','subscribe','true','update','upsert','where','workflow'
+        '@actions','@after','@as','@async','@before','@catch','@distinct','@enum','@expr','@from','@into','@meta','@oneof','@rbac','@ref','@then','@upsert','@with_unique','agent','allow','and','await','between','contains','create','delete','else','entity','error','event','extends','false','for','if','import','in','like','module','not','not_found','onSubscription','or','purge','query','read','record','relationship','resolver','return','roles','subscribe','true','update','upsert','where','workflow'
     ],
     operators: [
         '!=','*','+',',','-','.','/',':',';','<','<=','<>','=','>','>=','?','@'