agentlang 0.7.1 → 0.7.2

package/src/runtime/defs.ts

@@ -125,6 +125,7 @@ export enum SubGraphType {
   PURGE,
   RETURN,
   AGENT,
+  THROW,
   NONE,
 }
 
@@ -406,3 +407,29 @@ export function isRuntimeMode_generate_migration(): boolean {
 export function isRuntimeMode_undo_migration(): boolean {
   return RuntimeMode === RuntimeModeTag.UNDO_MIGRATION;
 }
+
+let UpdateEventEndpoints: Function | undefined;
+let UpdateEntityEndpoints: Function | undefined;
+
+export function setEventEndpointsUpdater(f: Function) {
+  UpdateEventEndpoints = f;
+}
+
+export function setEntityEndpointsUpdater(f: Function) {
+  UpdateEntityEndpoints = f;
+}
+
+export function updateEndpoints(moduleName: string) {
+  if (UpdateEventEndpoints !== undefined) {
+    UpdateEventEndpoints(moduleName);
+  }
+  if (UpdateEntityEndpoints !== undefined) {
+    UpdateEntityEndpoints(moduleName);
+  }
+}
+
+export let InternDynamicModule: Function | undefined;
+
+export function setInternDynamicModuleFn(f: Function) {
+  InternDynamicModule = f;
+}

package/src/runtime/exec-graph.ts

@@ -13,6 +13,7 @@ import {
   Purge,
   Return,
   Statement,
+  ThrowError,
 } from '../language/generated/ast.js';
 import { parseModule, parseStatement } from '../language/parser.js';
 import { ExecGraph, ExecGraphNode, ExecGraphWalker, SubGraphType } from './defs.js';
@@ -157,6 +158,15 @@ class GraphGenerator extends PatternHandler {
     this.handleSubPattern(SubGraphType.RETURN, ret.pattern, env);
   }
 
+  override async handleThrow(throwErr: ThrowError, env: Environment) {
+    const handler = new GraphGenerator();
+    await handler.handleExpression(
+      throwErr.reason,
+      Environment.from(env).setActiveUserData(throwErr.reason)
+    );
+    this.addSubGraph(SubGraphType.THROW, handler.getGraph(), env);
+  }
+
   getGraph(): ExecGraph {
     return this.graph;
   }
@@ -261,6 +271,9 @@ export async function executeGraph(execGraph: ExecGraph, env: Environment): Prom
               case SubGraphType.RETURN:
                 await executeReturnSubGraph(subg, env);
                 return;
+              case SubGraphType.THROW:
+                await evaluateExpression(subg.getRootNodes()[0].code as Expr, env);
+                throw new Error(env.getLastResult());
               default:
                 throw new Error(`Invalid sub-graph type: ${node.subGraphType}`);
             }

package/src/runtime/interpreter.ts

@@ -27,6 +27,7 @@ import {
   SelectIntoSpec,
   SetAttribute,
   Statement,
+  ThrowError,
 } from '../language/generated/ast.js';
 import {
   maybeInstanceAsString,
@@ -1217,6 +1218,10 @@ export class PatternHandler {
   async handleReturn(ret: Return, env: Environment) {
     await evaluatePattern(ret.pattern, env);
   }
+
+  async handleThrow(throwErr: ThrowError, env: Environment) {
+    await evaluateThrowError(throwErr, env);
+  }
 }
 
 const DefaultPatternHandler = new PatternHandler();
@@ -1243,9 +1248,16 @@ export async function evaluatePattern(
   } else if (pat.return) {
     await handler.handleReturn(pat.return, env);
     env.markForReturn();
+  } else if (pat.throwError) {
+    await handler.handleThrow(pat.throwError, env);
   }
 }
 
+async function evaluateThrowError(throwErr: ThrowError, env: Environment) {
+  await evaluateExpression(throwErr.reason, env);
+  throw new Error(env.getLastResult());
+}
+
 async function evaluateFullTextSearch(fts: FullTextSearch, env: Environment): Promise<void> {
   let n = escapeQueryName(fts.name);
   if (!isFqName(n)) {

package/src/runtime/loader.ts

@@ -1137,6 +1137,13 @@ export async function parseAndIntern(code: string, moduleName?: string) {
   await internModule(r.parseResult.value);
 }
 
+export async function refreshModuleDefinition(moduleName: string, moduleDefinition: string) {
+  removeModule(moduleName);
+  const r = await parse(moduleDefinition);
+  maybeRaiseParserErrors(r);
+  await internModule(r.parseResult.value);
+}
+
 export async function internModule(
   module: ModuleDefinition,
   moduleFileName?: string

package/src/runtime/modules/core.ts

@@ -9,7 +9,15 @@ import {
   restoreSpecialChars,
   makeCoreModuleName,
 } from '../util.js';
-import { Instance, isInstanceOfType, makeInstance, newInstanceAttributes } from '../module.js';
+import {
+  fetchModule,
+  Instance,
+  isInstanceOfType,
+  isModule,
+  makeInstance,
+  newInstanceAttributes,
+  removeModule,
+} from '../module.js';
 import {
   Environment,
   evaluate,
@@ -21,7 +29,12 @@ import { logger } from '../logger.js';
 import { Statement } from '../../language/generated/ast.js';
 import { parseModule, parseStatements } from '../../language/parser.js';
 import { Resolver } from '../resolvers/interface.js';
-import { FlowSuspensionTag, ForceReadPermFlag, PathAttributeName } from '../defs.js';
+import {
+  FlowSuspensionTag,
+  ForceReadPermFlag,
+  InternDynamicModule,
+  PathAttributeName,
+} from '../defs.js';
 import { getMonitor, getMonitorsForEvent, Monitor } from '../monitor.js';
 
 const CoreModuleDefinition = `module ${DefaultModuleName}
@@ -128,6 +141,18 @@ workflow validateModule {
   await Core.validateModule(validateModule.data)
 }
 
+entity Module {
+  name String @id,
+  definition String
+}
+
+resolver moduleResolver [agentlang/Module] {
+    create Core.createModule,
+    update Core.updateModule,
+    delete Core.deleteModule,
+    query Core.getModule
+}
+
 entity Migration {
   appVersion String @id,
   ups String @optional,
@@ -427,6 +452,46 @@ export async function validateModule(moduleDef: any): Promise<Instance> {
   }
 }
 
+export async function internModuleHelper(
+  name: string,
+  definition: string
+): Promise<string | undefined> {
+  if (InternDynamicModule !== undefined) {
+    return await InternDynamicModule(name, definition);
+  } else {
+    return undefined;
+  }
+}
+
+export async function createModule(_: Resolver, inst: Instance) {
+  await internModuleHelper(inst.lookup('name'), inst.lookup('definition'));
+  return inst;
+}
+
+export async function updateModule(r: Resolver, inst: Instance) {
+  return await createModule(r, inst);
+}
+
+export async function deleteModule(_: Resolver, inst: Instance) {
+  removeModule(inst.lookup('name'));
+  return inst;
+}
+
+export async function getModule(_: Resolver, inst: Instance) {
+  const p = inst.lookupQueryVal(PathAttributeName);
+  if (p !== undefined) {
+    const idx = p.lastIndexOf('/');
+    const n = p.substring(idx + 1);
+    if (isModule(n)) {
+      const m = fetchModule(n);
+      const defn = inst.lookup('definition') || m.toString();
+      const attrs = newInstanceAttributes().set('name', n).set('definition', defn);
+      return [makeInstance('agentlang', 'Module', attrs)];
+    }
+  }
+  return null;
+}
+
 const SqlSep = ';\n\n';
 
 export async function saveMigration(

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','@full_join','@inner_join','@into','@join','@left_join','@meta','@oneof','@public','@rbac','@ref','@right_join','@then','@upsert','@with_unique','agent','agentlang/retry','allow','and','attempts','await','backoff','between','case','commitTransaction','contains','create','decision','delete','directive','else','entity','error','event','extends','false','flow','for','glossaryEntry','if','import','in','like','module','not','not_found','onSubscription','or','purge','query','read','record','relationship','resolver','return','roles','rollbackTransaction','scenario','startTransaction','subscribe','true','update','upsert','where','workflow'
+        '@actions','@after','@as','@async','@before','@catch','@distinct','@enum','@expr','@from','@full_join','@inner_join','@into','@join','@left_join','@meta','@oneof','@public','@rbac','@ref','@right_join','@then','@upsert','@with_unique','agent','agentlang/retry','allow','and','attempts','await','backoff','between','case','commitTransaction','contains','create','decision','delete','directive','else','entity','error','event','extends','false','flow','for','glossaryEntry','if','import','in','like','module','not','not_found','onSubscription','or','purge','query','read','record','relationship','resolver','return','roles','rollbackTransaction','scenario','startTransaction','subscribe','throw','true','update','upsert','where','workflow'
     ],
     operators: [
         '!=','*','+',',','-','-->','.','/',':',';','<','<=','<>','=','==','>','>=','?','@'