agentlang 0.0.26 → 0.0.29

package/src/runtime/interpreter.ts

@@ -1062,7 +1062,7 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
       if (env.isInUpsertMode()) {
         await runPreUpdateEvents(inst, env);
         r = await res.upsertInstance(inst);
-        await runPostUpdateEvents(inst, env);
+        await runPostUpdateEvents(inst, undefined, env);
       } else {
         await runPreCreateEvents(inst, env);
         if (isTimer(inst)) triggerTimer(inst);
@@ -1178,7 +1178,7 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
               await computeExprAttributes(lastRes[i], env);
               await runPreUpdateEvents(lastRes[i], env);
               const finalInst: Instance = await resolver.updateInstance(lastRes[i], attrs);
-              await runPostUpdateEvents(finalInst, env);
+              await runPostUpdateEvents(finalInst, lastRes[i], env);
               res.push(finalInst);
             }
             env.setLastResult(res);
@@ -1190,7 +1190,7 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
           await computeExprAttributes(lastRes, env);
           await runPreUpdateEvents(lastRes, env);
           const finalInst: Instance = await res.updateInstance(lastRes, attrs);
-          await runPostUpdateEvents(finalInst, env);
+          await runPostUpdateEvents(finalInst, lastRes, env);
           env.setLastResult(finalInst);
         }
       }
@@ -1699,6 +1699,16 @@ async function realizeMap(mapLiteral: MapLiteral, env: Environment): Promise<voi
   env.setLastResult(Object.fromEntries(result.entries()));
 }
 
+export async function callPostEventOnSubscription(
+  crudType: CrudType,
+  inst: Instance,
+  env?: Environment
+): Promise<any> {
+  const newEnv = env ? env : new Environment('onSubs.env');
+  await runPrePostEvents(crudType, false, inst, newEnv);
+  return newEnv.getLastResult();
+}
+
 async function runPrePostEvents(
   crudType: CrudType,
   pre: boolean,
@@ -1730,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);
     }
   }
@@ -1752,9 +1765,13 @@ async function runPreUpdateEvents(inst: Instance, env: Environment) {
   await runPrePostEvents(CrudType.UPDATE, true, inst, env);
 }
 
-export async function runPostUpdateEvents(inst: Instance, env: Environment) {
+export async function runPostUpdateEvents(
+  inst: Instance,
+  oldInst: Instance | undefined,
+  env: Environment
+) {
   if (inst.requireAudit()) {
-    await addUpdateAudit(inst.getPath(), undefined, env);
+    await addUpdateAudit(inst.getPath(), oldInst, env);
   }
   await runPrePostEvents(CrudType.UPDATE, false, inst, env);
 }
@@ -1765,7 +1782,7 @@ async function runPreDeleteEvents(inst: Instance, env: Environment) {
 
 export async function runPostDeleteEvents(inst: Instance, env: Environment) {
   if (inst.requireAudit()) {
-    await addDeleteAudit(inst.getPath(), undefined, env);
+    await addDeleteAudit(inst.getPath(), inst, env);
   }
   await runPrePostEvents(CrudType.DELETE, false, inst, env);
 }

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 {
@@ -200,7 +200,7 @@ export type TriggerInfo = {
   async: boolean;
 };
 
-function asTriggerInfo(te: TriggerEntry): TriggerInfo {
+function asTriggerInfo(te: any): TriggerInfo {
   return {
     eventName: te.event,
     async: te.async ? true : false,
@@ -338,6 +338,22 @@ export class Record extends ModuleEntry {
     return this;
   }
 
+  public addAfterTrigger(te: any): Record {
+    if (this.afterTriggers == undefined) {
+      this.afterTriggers = new Map();
+    }
+    this.afterTriggers?.set(asCrudType(te.on), asTriggerInfo(te));
+    return this;
+  }
+
+  public addBeforeTrigger(te: any): Record {
+    if (this.beforeTriggers == undefined) {
+      this.beforeTriggers = new Map();
+    }
+    this.beforeTriggers?.set(asCrudType(te.on), asTriggerInfo(te));
+    return this;
+  }
+
   getCompositeUniqueAttributes(): Array<string> | undefined {
     return this.compositeUqAttributes;
   }
@@ -1141,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> {
@@ -1262,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}');
@@ -1871,8 +1895,11 @@ export function addWorkflow(
   name: string,
   moduleName = activeModule,
   statements?: Statement[],
-  hints?: WorkflowHint[]
+  hdr?: WorkflowHeader
 ): 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);
@@ -1884,14 +1911,51 @@ export function addWorkflow(
     event.addMeta(SystemDefinedEvent, 'true');
   }
   if (!statements) statements = new Array<Statement>();
-  if (hints && hints.length > 0) {
-    hints.forEach((hint: WorkflowHint) => {
-      if (hint.subs) {
-        SetSubscription(makeFqName(moduleName, name), hint.subs.resolverName);
-      }
-    });
+  if (hdr) {
+    const eventFqName = makeFqName(moduleName, name);
+    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 prePostWorkflowName(
+  tag: '@after' | '@before',
+  opr: 'create' | 'update' | 'delete',
+  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);
 }
 
 export function getWorkflow(eventInstance: Instance): Workflow {
@@ -1905,12 +1969,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 {
@@ -2225,6 +2290,14 @@ export class Instance {
     );
   }
 
+  static clone(inst: Instance): Instance {
+    const attrs = newInstanceAttributes();
+    inst.attributes.forEach((v: any, k: string) => {
+      attrs.set(k, v);
+    });
+    return Instance.newWithAttributes(inst, attrs);
+  }
+
   normalizeAttributes(attrs: InstanceAttributes): InstanceAttributes {
     attrs.forEach((v: any, k: string) => {
       const attrSpec = this.record.schema.get(k);
@@ -2730,7 +2803,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/runtime/modules/core.ts

@@ -1,6 +1,6 @@
 import { default as ai } from './ai.js';
 import { default as auth } from './auth.js';
-import { DefaultModuleName, DefaultModules } from '../util.js';
+import { DefaultModuleName, DefaultModules, escapeSpecialChars } from '../util.js';
 import { Instance, isInstanceOfType, makeInstance, newInstanceAttributes } from '../module.js';
 import {
   Environment,
@@ -103,7 +103,7 @@ async function addAudit(
     `{agentlang/auditlog {
         action "${action}",
         resource "${resource}",
-        previous_value "${previuos_value ? JSON.stringify(previuos_value.asObject()) : ''}",
+        previous_value "${previuos_value ? escapeSpecialChars(JSON.stringify(previuos_value.asObject())) : ''}",
         user "${user}",
         token "${token ? token : ''}"
 }}`,

package/src/runtime/resolvers/interface.ts

@@ -1,4 +1,5 @@
 import {
+  callPostEventOnSubscription,
   Environment,
   evaluate,
   runPostCreateEvents,
@@ -206,7 +207,7 @@ export class Resolver {
       case CrudType.CREATE:
         return await runPostCreateEvents(inst, env);
       case CrudType.UPDATE:
-        return await runPostUpdateEvents(inst, env);
+        return await runPostUpdateEvents(inst, undefined, env);
       case CrudType.DELETE:
         return await runPostDeleteEvents(inst, env);
       default:
@@ -226,18 +227,23 @@ export class Resolver {
     return this.onOutOfBandCrud(inst, CrudType.DELETE, env);
   }
 
-  public async onSubscription(result: any): Promise<any> {
+  public async onSubscription(result: any, callPostCrudEvent: boolean = false): Promise<any> {
     if (result != undefined) {
       try {
-        const eventName = getSubscriptionEvent(this.name);
-        if (eventName) {
-          const path = splitFqName(eventName);
-          const inst = makeInstance(
-            path.getModuleName(),
-            path.getEntryName(),
-            newInstanceAttributes().set('data', result)
-          );
-          return await evaluate(inst);
+        if (callPostCrudEvent) {
+          const inst = result as Instance;
+          return await callPostEventOnSubscription(CrudType.CREATE, inst);
+        } else {
+          const eventName = getSubscriptionEvent(this.name);
+          if (eventName) {
+            const path = splitFqName(eventName);
+            const inst = makeInstance(
+              path.getModuleName(),
+              path.getEntryName(),
+              newInstanceAttributes().set('data', result)
+            );
+            return await evaluate(inst);
+          }
         }
       } catch (err: any) {
         logger.error(`Resolver ${this.name} raised error in onSubscription handler: ${err}`);

package/src/runtime/resolvers/sqldb/impl.ts

@@ -146,7 +146,7 @@ export class SqlDbResolver extends Resolver {
       updateObj,
       this.getDbContext(inst.getFqName())
     );
-    return inst.mergeAttributes(newAttrs);
+    return Instance.clone(inst).mergeAttributes(newAttrs);
   }
 
   static EmptyResultSet: Array<Instance> = new Array<Instance>();

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: [
         '!=','*','+',',','-','.','/',':',';','<','<=','<>','=','>','>=','?','@'