agentlang 0.7.1 → 0.7.3

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,
@@ -49,7 +50,7 @@ import {
   PlaceholderRecordEntry,
   Relationship,
   Workflow,
-  maybeSetMetaAttributes,
+  setMetaAttributes,
 } from './module.js';
 import { JoinInfo, Resolver } from './resolvers/interface.js';
 import { ResolverAuthInfo } from './resolvers/authinfo.js';
@@ -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)) {
@@ -1461,7 +1473,7 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
       const res: Resolver = await getResolverForPath(entryName, moduleName, env);
       let r: Instance | undefined;
       await computeExprAttributes(inst, undefined, undefined, env);
-      maybeSetMetaAttributes(inst.attributes, env);
+      setMetaAttributes(inst.attributes, env);
       if (env.isInUpsertMode()) {
         await runPreUpdateEvents(inst, env);
         r = await res.upsertInstance(inst);
@@ -1581,7 +1593,7 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
               await computeExprAttributes(lastRes[i], crud.body?.attributes, attrs, env);
               env.attributes.set('__patch', attrs);
               await runPreUpdateEvents(lastRes[i], env);
-              maybeSetMetaAttributes(attrs, env, true);
+              setMetaAttributes(attrs, env, true);
               const finalInst: Instance = await resolver.updateInstance(lastRes[i], attrs);
               await runPostUpdateEvents(finalInst, lastRes[i], env);
               res.push(finalInst);

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/module.ts

@@ -1248,7 +1248,7 @@ export class Relationship extends Record {
 
   constructor(
     name: string,
-    typ: string,
+    type: string,
     node1: RelationshipNode,
     node2: RelationshipNode,
     moduleName: string,
@@ -1256,7 +1256,7 @@ export class Relationship extends Record {
     props?: Map<string, any>
   ) {
     super(name, moduleName, scm);
-    if (typ == 'between') {
+    if (type == 'between') {
       this.relType = RelType.BETWEEN;
       this.addMetaAttributes();
     }
@@ -3999,7 +3999,7 @@ export function getAttributeNames(entityFqName: string): Array<string> {
   return [...scm.keys()];
 }
 
-export function maybeSetMetaAttributes(
+export function setMetaAttributes(
   attrs: InstanceAttributes,
   env: Environment,
   inUpdateMode: boolean = false
@@ -4010,3 +4010,12 @@ export function maybeSetMetaAttributes(
     attrs.set(SysAttr_CreatedBy, user);
   }
 }
+
+export function setAllMetaAttributes(
+  attrs: InstanceAttributes,
+  env: Environment,
+  inUpdateMode: boolean = false
+) {
+  attrs.set(SysAttr_Created, now());
+  setMetaAttributes(attrs, env, inUpdateMode);
+}

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/runtime/resolvers/sqldb/database.ts

@@ -24,6 +24,7 @@ import {
   RbacPermissionFlag,
   RbacSpecification,
   Relationship,
+  setAllMetaAttributes,
 } from '../../module.js';
 import { isString } from '../../util.js';
 import {
@@ -646,6 +647,7 @@ export async function insertBetweenRow(
     if (relEntry.isOneToMany()) {
       attrs.set(relEntry.joinNodesAttributeName(), `${p1}_${p2}`);
     }
+    setAllMetaAttributes(attrs, ctx.activeEnv);
     const row = Object.fromEntries(attrs);
     await insertRow(n, row, ctx.clone().setNeedAuthCheck(false), false);
   } else {

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

@@ -435,6 +435,7 @@ export class SqlDbResolver extends Resolver {
     const a1: string = relEntry.node1.alias;
     const a2: string = relEntry.node2.alias;
     const n1path: any = orUpdate ? firstNode.lookup(PathAttributeName) : undefined;
+    const ctx = this.getDbContext(relEntry.getFqName());
     if (relEntry.isOneToOne()) {
       await this.updateInstance(
         node1,
@@ -452,18 +453,10 @@ export class SqlDbResolver extends Resolver {
             [a1, n1path],
             [a2, secondNode.lookup(PathAttributeName)],
           ],
-          this.getDbContext(relEntry.getFqName())
+          ctx
         );
       }
-      await insertBetweenRow(
-        n,
-        a1,
-        a2,
-        firstNode,
-        secondNode,
-        relEntry,
-        this.getDbContext(relEntry.getFqName())
-      );
+      await insertBetweenRow(n, a1, a2, firstNode, secondNode, relEntry, ctx);
     }
   }
 

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