agentlang 0.0.13 → 0.0.14

package/src/runtime/agents/common.ts

@@ -1,6 +1,6 @@
 export const PlannerInstructions = `Agentlang is a very-high-level declarative language that makes it easy to define business applications as 'models'.
 The model of a business application consists of entity definitions and workflows defined in "modules". 
-A module will be encoded in a syntax inspired by JavaScript and JSON. Example of a simple module definition is,
+A module is be encoded in a syntax inspired by JavaScript and JSON. Example of a simple module follows:
 
 module Erp
 
@@ -12,9 +12,10 @@ entity Employee {
    email Email @indexed
 }
 
-The Empoyee entity is part of the "Erp" module and it has four attributes: employeeId, firstName, lastName, salary and email. The employeeId uniquely identifies an
-Employee and it's automatically filled-in by the system by calling the "uuid()" function. (In the place of the keyword 'entity', the keyword 'record' may also be used.
-The difference between an entity and a record is that, instances of an entity is persisted to the database, instances of records are not).
+The Empoyee entity is part of the "Erp" module and it has four attributes: 'employeeId', 'firstName', 'lastName', 'salary' and 'email'. 
+The 'employeeId' attribute uniquely identifies an instance of the Employee entity and it's automatically filled-in by the system by calling the "uuid()" function. 
+In the place of the keyword 'entity', the keyword 'record' may also be used. The difference between an entity and a record is that, 
+instances of an entity is persisted to the database, instances of records are not.
 
 This is an example of a record:
 
@@ -25,7 +26,8 @@ record EmailMessage {
     body String
 }
 
-Workflows contains JSON "patterns" that perform CRUD operations on entities. For example, here's is a workflow that creates a new instance of the Employee entity:
+Another major construct in Agentlang is the 'workflow'. Workflows contains JSON "patterns" that perform CRUD operations on entities. 
+For example, here's is a workflow that creates a new instance of the Employee entity:
 
 workflow CreateEmployee {
     {Erp/Employee {firstName CreateEmployee.firstName,
@@ -49,7 +51,7 @@ A workflow attached to an event is invoked by creating an instance of the event,
 
 {Erp/CreateEmployee {firstName "Sam", lastName "K", salary 1400, email "samk@acme.com"}}
 
-This means a workflow can be invoked from another workflow, simply by adding the event-creation as a pattern.
+This means a workflow can be invoked from another workflow, simply by having the event-creation pattern.
 
 Other than the create-pattern for entities and events, some of the most useful patterns (related to entities) that can appear in a workflow are:
 1. Query - e.g: '{Erp/Employee {employeeId? "56392e13-0d9a-42f7-b556-0d7cd9468a24"}}'. The attributes by which the query happens must end with a '?' character.
@@ -58,7 +60,7 @@ Other than the create-pattern for entities and events, some of the most useful p
    with the given employeeId.
 3. Upsert - e.g: '{Erp/Employee {employeeId "56392e13-0d9a-42f7-b556-0d7cd9468a24", firstName "Joe"}, @upsert}'. The 'upsert' pattern will create a new
    instance, if the instance does not already exist.
-4. Delete - e.g: delete '{Erp/Employee {employeeId? "56392e13-0d9a-42f7-b556-0d7cd9468a24"}}'
+4. Delete - e.g: 'delete {Erp/Employee {employeeId? "56392e13-0d9a-42f7-b556-0d7cd9468a24"}}'
 
 The default query operator is '=' (equals). So an expression like 'employeeId? "56392e13-0d9a-42f7-b556-0d7cd9468a24"' means,
 'where employeeId equals "56392e13-0d9a-42f7-b556-0d7cd9468a24"'. Other comparison operators has to be specified explicitly, as in
@@ -89,6 +91,19 @@ workflow IncrementSalary {
 
 Note the value passed to the 'salary' attribute - it's an arithmetic expression. All normal arithmetic expressions are supported by workflow patterns.
 
+Another example of the 'if' pattern:
+
+workflow validateLicense {
+    {checkLicenseNumber {number validateLicense.number}} @as response;
+    if (response = "ok") {
+        {license {number? validateLicense.number, status "active"}}
+    } else {
+        {license {number? validateLicense.number, status "canceled"}}
+    }
+}
+
+Also note the use of the '@as' keyword - this binds the result of a pattern to an 'alias'.
+
 A successful query pattern will return an array of instances. The 'for' pattern can be used to iterate over an array. An example follows:
 
 workflow NotifyEmployees {
@@ -98,8 +113,7 @@ workflow NotifyEmployees {
     }
 }
 
-Also note the use of the '@as' keyword - this binds the result of a pattern to an 'alias'. Here the result of the query is bound to the
-alias named 'employees'. Any pattern can have an alias, including 'if' and 'for'. An alias can be used to refer to the attributes of the instance, 
+Here the result of the query is bound to the alias named 'employees'. Any pattern can have an alias, including 'if' and 'for'. An alias can be used to refer to the attributes of the instance, 
 via the dot(.) notation. Aliases can also be used to destructure a query result - here's an example:
 
 workflow FindFirstTwoEmployees {
@@ -134,6 +148,15 @@ A fix for the reference-error is shown below:
 {Employee {id? 101}} @as employee;
 {SendEmail {to employee.email, body "hello"}}
 
+A pattern may execute asynchronously and its eventual result can be handled by patterns provided in the '@then' clause. An example is shown below:
+
+{sendChatMessage {to "amy", "text" "hello"}} @as response @then {
+    {saveResponse {from "amy", "text" response}}
+}
+
+If you are instructed that a particular event will be called asynchronously, always provide the patterns that follows in its '@then' clause. You must add the 
+'@then' clause only if an event's documentation or instruction explicitly requires to do so.
+
 Entities in a module can be connected together in relationships. There are two types of relationships - 'contains' and 'between'.
 'Contains' relationship is for hierarchical data, as in a Library entity containing Books. 'Between' relationship is for graph-like data,
 like two Profiles in a social media app is connected as friends. A 'between' relationship can be one of the following three types - 'one_one' (one-to-one),

package/src/runtime/integrations.ts

@@ -0,0 +1,92 @@
+import { Instance } from './module.js';
+import { isString } from './util.js';
+
+const Integrations = new Map<string, Instance>();
+
+const IntegManagerModel = 'integmanager.core';
+
+export async function prepareIntegrations(
+  integManagerHost: string,
+  username: string | undefined,
+  password: string | undefined,
+  integConfigObj: object
+) {
+  const integConfig = new Map(Object.entries(integConfigObj));
+  const standardHeaders = await loginToIntegManager(integManagerHost, username, password);
+  const keys = [...integConfig.keys()];
+  for (let i = 0; i < keys.length; ++i) {
+    const configName = keys[i];
+    const configPath = integConfig.get(configName);
+    if (configPath) {
+      const apiUrl = mkApiUrl(integManagerHost, configPath);
+      const response = await fetch(apiUrl, {
+        method: 'GET',
+        headers: standardHeaders,
+      });
+
+      if (!response.ok) {
+        throw new Error(
+          `Failed to fetch integration for ${configPath}, HTTP error! status: ${response.status} ${response.text} ${response.statusText}`
+        );
+      }
+
+      const data = await response.json();
+      if (data.length > 0) {
+        const inst: any = data[0].config;
+        if (inst.type == 'custom' && isString(inst.parameter)) {
+          inst.parameter = new Map(Object.entries(JSON.parse(inst.parameter)));
+        }
+        Integrations.set(configName, inst);
+      } else {
+        throw new Error(`Integration not found for ${configPath}`);
+      }
+    }
+  }
+}
+
+async function loginToIntegManager(
+  host: string,
+  username?: string,
+  password?: string
+): Promise<any> {
+  const defaultHdr = { 'Content-Type': 'application/json' };
+  if (username && password && username.length > 0) {
+    const apiUrl = `${host}/agentlang_auth/login`;
+    const data = { email: username, password: password };
+    const response = await fetch(apiUrl, {
+      method: 'POST',
+      headers: defaultHdr,
+      body: JSON.stringify(data),
+    });
+
+    if (!response.ok) {
+      throw new Error(
+        `Failed to login to integration-manager. HTTP error! status: ${response.status}`
+      );
+    }
+
+    const responseData = await response.json();
+    return {
+      Authorization: `Bearer ${responseData.id_token}`,
+      'Content-Type': 'application/json',
+    };
+  } else {
+    return defaultHdr;
+  }
+}
+
+function mkApiUrl(integManagerHost: string, configPath: string): string {
+  const parts = configPath.split('/');
+  const integId = parts[0];
+  const configId = parts[1];
+  return `${integManagerHost}/${IntegManagerModel}/integration/${integId}/integrationConfig/config/${configId}`;
+}
+
+export function getIntegrationConfig(name: string, configName: string): any {
+  const config: any = Integrations.get(name);
+  if (config) {
+    return config.parameter.get(configName);
+  } else {
+    return undefined;
+  }
+}

package/src/runtime/interpreter.ts

@@ -13,6 +13,7 @@ import {
   isLiteral,
   isNegExpr,
   isNotExpr,
+  isReturn,
   Literal,
   MapKey,
   MapLiteral,
@@ -607,27 +608,28 @@ function statemtentString(stmt: Statement): string {
   }
 }
 
+async function saveSuspension(cont: Statement[], env: Environment) {
+  if (cont.length > 0) {
+    const suspId = await createSuspension(
+      env.getSuspensionId(),
+      cont.map((stmt: Statement) => {
+        return statemtentString(stmt);
+      }),
+      env
+    );
+    env.setLastResult({ suspension: suspId || 'null' });
+  }
+}
+
 export async function evaluateStatements(
   stmts: Statement[],
   env: Environment,
   continuation?: Function
 ) {
   for (let i = 0; i < stmts.length; ++i) {
-    await evaluateStatement(stmts[i], env);
-    if (env.isSuspended()) {
-      const cont = stmts.slice(i + 1, stmts.length);
-      if (cont.length > 0) {
-        const suspId = await createSuspension(
-          env.getSuspensionId(),
-          cont.map((stmt: Statement) => {
-            return statemtentString(stmt);
-          }),
-          env
-        );
-        env.setLastResult({ suspension: suspId || 'null' });
-        break;
-      }
-    } else if (env.isMarkedForReturn()) {
+    const stmt = stmts[i];
+    await evaluateStatement(stmt, env);
+    if (env.isMarkedForReturn()) {
       break;
     }
   }
@@ -636,10 +638,44 @@ export async function evaluateStatements(
   }
 }
 
+async function evaluateAsyncPattern(
+  pat: Pattern,
+  thenStmts: Statement[],
+  handlers: CatchHandlers | undefined,
+  hints: RuntimeHint[],
+  env: Environment
+): Promise<void> {
+  try {
+    await evaluatePattern(pat, env);
+    maybeBindStatementResultToAlias(hints, env);
+    if (env.isSuspended()) {
+      await saveSuspension(thenStmts, env);
+    } else {
+      await evaluateStatements(thenStmts, env);
+    }
+  } catch (reason: any) {
+    await maybeHandleError(handlers, reason, env);
+  }
+}
+
 async function evaluateStatement(stmt: Statement, env: Environment): Promise<void> {
   const hints = stmt.hints;
   const hasHints = hints && hints.length > 0;
+  const thenStmts: Statement[] | undefined = hasHints ? maybeFindThenStatements(hints) : undefined;
   const handlers: CatchHandlers | undefined = hasHints ? maybeFindHandlers(hints) : undefined;
+  if (thenStmts) {
+    evaluateAsyncPattern(
+      stmt.pattern,
+      thenStmts,
+      handlers,
+      hints,
+      new Environment(env.name + 'async', env)
+    );
+    if (isReturn(stmt.pattern)) {
+      env.markForReturn();
+    }
+    return;
+  }
   let handlersPushed = false;
   try {
     if (handlers) {
@@ -649,24 +685,9 @@ async function evaluateStatement(stmt: Statement, env: Environment): Promise<voi
     if (hasHints) {
       maybeBindStatementResultToAlias(hints, env);
     }
-    const lastResult: Result = env.getLastResult();
-    if (
-      lastResult == null ||
-      lastResult == undefined ||
-      (lastResult instanceof Array && lastResult.length == 0)
-    ) {
-      const onNotFound = handlers ? handlers.get('not_found') : undefined;
-      if (onNotFound) {
-        await evaluateStatement(onNotFound, env);
-      }
-    }
+    await maybeHandleNotFound(handlers, env);
   } catch (reason: any) {
-    const handler = handlers ? handlers.get('error') : undefined;
-    if (handler) {
-      await evaluateStatement(handler, env);
-    } else {
-      throw reason;
-    }
+    await maybeHandleError(handlers, reason, env);
   } finally {
     if (handlersPushed && env.hasHandlers()) {
       env.popHandlers();
@@ -674,6 +695,33 @@ async function evaluateStatement(stmt: Statement, env: Environment): Promise<voi
   }
 }
 
+async function maybeHandleNotFound(handlers: CatchHandlers | undefined, env: Environment) {
+  const lastResult: Result = env.getLastResult();
+  if (
+    lastResult == null ||
+    lastResult == undefined ||
+    (lastResult instanceof Array && lastResult.length == 0)
+  ) {
+    const onNotFound = handlers ? handlers.get('not_found') : undefined;
+    if (onNotFound) {
+      await evaluateStatement(onNotFound, env);
+    }
+  }
+}
+
+async function maybeHandleError(
+  handlers: CatchHandlers | undefined,
+  reason: any,
+  env: Environment
+) {
+  const handler = handlers ? handlers.get('error') : undefined;
+  if (handler) {
+    await evaluateStatement(handler, env);
+  } else {
+    throw reason;
+  }
+}
+
 function maybeBindStatementResultToAlias(hints: RuntimeHint[], env: Environment) {
   for (let i = 0; i < hints.length; ++i) {
     const rh = hints[i];
@@ -720,6 +768,16 @@ function maybeFindHandlers(hints: RuntimeHint[]): Map<string, Statement> | undef
   return undefined;
 }
 
+function maybeFindThenStatements(hints: RuntimeHint[]): Statement[] | undefined {
+  for (let i = 0; i < hints.length; ++i) {
+    const rh = hints[i];
+    if (rh.thenSpec) {
+      return rh.thenSpec.statements;
+    }
+  }
+  return undefined;
+}
+
 export async function parseAndEvaluateStatement(
   stmtString: string,
   activeUserId?: string,
@@ -1237,9 +1295,11 @@ async function walkJoinQueryPattern(
 async function handleAgentInvocation(agentEventInst: Instance, env: Environment): Promise<void> {
   const agent: AgentInstance = await findAgentByName(agentEventInst.name, env);
   await agent.invoke(agentEventInst.lookup('message'), env);
-  const result: string | undefined = cleanupAgentResponse(env.getLastResult());
+  const r: string | undefined = env.getLastResult();
+  const isPlanner = agent.isPlanner();
+  const result: string | undefined = isPlanner ? cleanupAgentResponse(r) : r;
   if (result) {
-    if (agent.isPlanner()) {
+    if (isPlanner) {
       logger.debug(`Agent ${agent.name} generated pattern: ${result}`);
       try {
         let rs = result.trim();
@@ -1310,11 +1370,13 @@ async function evaluateForEach(forEach: ForEach, env: Environment): Promise<void
   const src: Result = env.getLastResult();
   if (src instanceof Array && src.length > 0) {
     const loopEnv: Environment = Environment.from(env);
+    const finalResult = new Array<any>();
     for (let i = 0; i < src.length; ++i) {
       loopEnv.bind(loopVar, src[i]);
       await evaluateStatements(forEach.statements, loopEnv);
+      finalResult.push(loopEnv.getLastResult());
     }
-    env.setLastResult(loopEnv.getLastResult());
+    env.setLastResult(finalResult);
   } else {
     env.setLastResult(EmptyResult);
   }

package/src/runtime/loader.ts

@@ -421,7 +421,7 @@ async function addAgentDefinition(def: AgentDefinition, moduleName: string) {
       v = apdef.value.array.vals
         .map((stmt: Statement) => {
           if (stmt.pattern.expr && isLiteral(stmt.pattern.expr)) {
-            const s = stmt.pattern.expr.str || stmt.pattern.expr.id;
+            const s = stmt.pattern.expr.str || stmt.pattern.expr.id || stmt.pattern.expr.ref;
             if (s == undefined) {
               throw new Error(
                 `Only arrays of string-literals or identifiers should be passed to agent ${name}`
@@ -434,7 +434,7 @@ async function addAgentDefinition(def: AgentDefinition, moduleName: string) {
         })
         .join(',');
     } else {
-      v = apdef.value.str || apdef.value.id || apdef.value.num;
+      v = apdef.value.str || apdef.value.id || apdef.value.ref || apdef.value.num;
       if (v == undefined) {
         v = apdef.value.bool;
       }

package/src/runtime/module.ts

@@ -2206,14 +2206,27 @@ export class Instance {
     return obj;
   }
 
+  static isSerializableObject(obj: any): boolean {
+    return obj instanceof Object && obj.AL_INSTANCE == true;
+  }
+
+  static DeserializeAttributes(attrs: InstanceAttributes): InstanceAttributes {
+    attrs.forEach((v: any, k: string) => {
+      if (Instance.isSerializableObject(v)) {
+        attrs.set(k, Instance.FromSerializableObject(v));
+      }
+    });
+    return attrs;
+  }
+
   static FromSerializableObject(obj: any, record?: Record): Instance {
-    if (obj.AL_INSTANCE == true) {
+    if (Instance.isSerializableObject(obj)) {
       const m = fetchModule(obj.moduleName);
       return new Instance(
         record || (m.getEntry(obj.name) as Record),
         obj.moduleName,
         obj.name,
-        new Map(Object.entries(obj.attributes)),
+        Instance.DeserializeAttributes(new Map(Object.entries(obj.attributes))),
         new Map(Object.entries(obj.queryAttributes)),
         new Map(Object.entries(obj.queryAttributeValues))
       );

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

@@ -239,7 +239,7 @@ export async function resetDefaultDatabase() {
 }
 
 function ownersTable(tableName: string): string {
-  return (tableName + OwnersSuffix).toLowerCase();
+  return (tableName.replace('.', '_') + OwnersSuffix).toLowerCase();
 }
 
 async function insertRowsHelper(

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

@@ -31,13 +31,14 @@ export type TableSchema = {
 };
 
 export function asTableReference(moduleName: string, ref: string): string {
+  const modName = moduleName.replace('.', '_')
   if (ref.indexOf('.') > 0) {
     const parts = ref.split('.')
-    const r = `${moduleName}_${parts[0]}`.toLowerCase()
+    const r = `${modName}_${parts[0]}`.toLowerCase()
     const colref = parts.slice(1).join('.')
     return `"${r}"."${colref}"`;
   } else {
-    return `${moduleName}_${ref}`.toLowerCase()
+    return `${modName}_${ref}`.toLowerCase()
   }
 }
 

package/src/runtime/state.ts

@@ -33,6 +33,14 @@ export const ConfigSchema = z.object({
       }),
     ])
     .optional(),
+  integrations: z
+    .object({
+      host: z.string(),
+      username: z.string().optional(),
+      password: z.string().optional(),
+      connections: z.record(z.string(), z.string()),
+    })
+    .optional(),
   graphql: z
     .object({
       enabled: z.boolean().default(false),

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