agentlang 0.10.0 → 0.10.2

package/src/language/parser.ts

@@ -8,6 +8,7 @@ import {
   ForEach,
   FullTextSearch,
   Group,
+  GroupByClause,
   Handler,
   If,
   isExpr,
@@ -24,17 +25,27 @@ import {
   ModuleDefinition,
   NegExpr,
   NotExpr,
+  OrderByClause,
   Pattern,
   PrimExpr,
+  QueryOption,
   RelationshipPattern,
   Return,
   SelectIntoEntry,
   SelectIntoSpec,
   SetAttribute,
   Statement,
+  WhereSpec,
+  WhereSpecClause,
   WorkflowDefinition,
 } from './generated/ast.js';
-import { firstAliasSpec, firstCatchSpec, isString, QuerySuffix } from '../runtime/util.js';
+import {
+  firstAliasSpec,
+  firstCatchSpec,
+  firstEmptySpec,
+  isString,
+  QuerySuffix,
+} from '../runtime/util.js';
 import {
   BasePattern,
   CrudPattern,
@@ -50,6 +61,7 @@ import {
   NegExpressionPattern,
   NotExpressionPattern,
   ReturnPattern,
+  WhereSpecClausePattern,
 } from './syntax.js';
 
 let nextDocumentId = 1;
@@ -258,6 +270,10 @@ function introspectStatement(stmt: Statement): BasePattern {
       r.addHandler(h.except, introspectStatement(h.stmt));
     });
   }
+  const emptySpec = firstEmptySpec(stmt);
+  if (emptySpec) {
+    r.setEmptyHandler(introspectStatement(emptySpec.stmt));
+  }
   return r;
 }
 
@@ -269,8 +285,9 @@ function introspectPattern(pat: Pattern): BasePattern {
     } else {
       r = introspectCreatePattern(pat.crudMap);
     }
-    if (pat.crudMap.into) {
-      r = introspectInto(pat.crudMap.into, r as CrudPattern);
+    const opts = extractQueryOptions(pat.crudMap);
+    if (opts.into) {
+      r = introspectInto(opts.into, r as CrudPattern);
     }
   } else if (pat.expr) {
     r = introspectExpression(pat.expr);
@@ -294,6 +311,14 @@ function introspectPattern(pat: Pattern): BasePattern {
 function introspectInto(intoSpec: SelectIntoSpec, p: CrudPattern): CrudPattern {
   intoSpec.entries.forEach((se: SelectIntoEntry) => {
     if (se.attribute) p.addInto(se.alias, se.attribute);
+    else if (se.aggregate) {
+      const args = se.aggregate.args
+        .map((s: string) => {
+          return s;
+        })
+        .join(', ');
+      p.addInto(se.alias, `@${se.aggregate?.name}(${args})`);
+    }
   });
   return p;
 }
@@ -360,10 +385,11 @@ function introspectQueryPattern(crudMap: CrudMap): CrudPattern {
     crudMap.body?.attributes.forEach((sa: SetAttribute) => {
       cp.addAttribute(sa.name, introspectExpression(sa.value), sa.op);
     });
-    crudMap.relationships.forEach((rp: RelationshipPattern) => {
+    const opts = extractQueryOptions(crudMap);
+    crudMap.relationships?.forEach((rp: RelationshipPattern) => {
       cp.addRelationship(rp.name, introspectPattern(rp.pattern) as CrudPattern | CrudPattern[]);
     });
-    crudMap.joins.forEach((js: JoinSpec) => {
+    opts.joins?.forEach((js: JoinSpec) => {
       const jp: JoinPattern = {
         type: js.type,
         targetEntity: js.name,
@@ -373,6 +399,18 @@ function introspectQueryPattern(crudMap: CrudMap): CrudPattern {
       };
       cp.joins.push(jp);
     });
+    if (opts.where?.clauses) {
+      cp.where = new Array<WhereSpecClausePattern>();
+      opts.where.clauses.forEach((wc: WhereSpecClause) => {
+        cp.where?.push({ lhs: wc.lhs, op: wc.op || '=', rhs: wc.rhs.$cstNode?.text || '' });
+      });
+    }
+    if (opts.groupByClause) {
+      cp.groupBy = opts.groupByClause.colNames;
+    }
+    if (opts.orderByClause) {
+      cp.orderBy = opts.orderByClause.colNames;
+    }
     cp.isCreate = false;
     cp.isQueryUpdate = false;
     cp.isQuery = true;
@@ -381,6 +419,49 @@ function introspectQueryPattern(crudMap: CrudMap): CrudPattern {
   throw new Error(`Failed to introspect query-pattern: ${crudMap}`);
 }
 
+export type ExtractedQueryOptions = {
+  joins: JoinSpec[] | undefined;
+  into: SelectIntoSpec | undefined;
+  where: WhereSpec | undefined;
+  groupByClause: GroupByClause | undefined;
+  orderByClause: OrderByClause | undefined;
+  upsert: '@upsert' | undefined;
+  distinct: '@distinct' | undefined;
+};
+
+export function extractQueryOptions(crudMap: CrudMap): ExtractedQueryOptions {
+  const r: ExtractedQueryOptions = {
+    joins: undefined,
+    into: undefined,
+    where: undefined,
+    groupByClause: undefined,
+    orderByClause: undefined,
+    upsert: undefined,
+    distinct: undefined,
+  };
+  crudMap.queryOptions.forEach((qo: QueryOption) => {
+    if (qo.join) {
+      if (r.joins === undefined) {
+        r.joins = new Array<JoinSpec>();
+      }
+      r.joins.push(qo.join);
+    } else if (qo.into) {
+      r.into = qo.into;
+    } else if (qo.where) {
+      r.where = qo.where;
+    } else if (qo.groupByClause) {
+      r.groupByClause = qo.groupByClause;
+    } else if (qo.orderByClause) {
+      r.orderByClause = qo.orderByClause;
+    } else if (qo.upsert) {
+      r.upsert = qo.upsert;
+    } else if (qo.distinct) {
+      r.distinct = qo.distinct;
+    }
+  });
+  return r;
+}
+
 function introspectCreatePattern(crudMap: CrudMap): CrudPattern {
   if (crudMap) {
     const cp: CrudPattern = new CrudPattern(crudMap.name);
@@ -393,7 +474,7 @@ function introspectCreatePattern(crudMap: CrudMap): CrudPattern {
       }
       cp.addAttribute(sa.name, introspectExpression(sa.value), sa.op);
     });
-    crudMap.relationships.forEach((rp: RelationshipPattern) => {
+    crudMap.relationships?.forEach((rp: RelationshipPattern) => {
       cp.addRelationship(rp.name, introspectPattern(rp.pattern) as CrudPattern | CrudPattern[]);
     });
     cp.isQueryUpdate = qup;

package/src/language/syntax.ts

@@ -15,6 +15,7 @@ export class BasePattern {
   alias: string | undefined;
   aliases: string[] | undefined;
   handlers: Map<string, BasePattern> | undefined;
+  emptyHandler: BasePattern | undefined;
 
   setAlias(alias: string) {
     this.alias = alias;
@@ -44,6 +45,11 @@ export class BasePattern {
     this.handlers.set(k, handler);
   }
 
+  setEmptyHandler(handler: BasePattern) {
+    this.emptyHandler = handler;
+    return this;
+  }
+
   private aliasesAsString(): string | undefined {
     if (this.alias) {
       return ` @as ${this.alias}`;
@@ -54,24 +60,30 @@ export class BasePattern {
     }
   }
 
+  private emptyHandlerAsString(): string | undefined {
+    if (this.emptyHandler) {
+      return ` @empty ${this.emptyHandler.toString()}`;
+    }
+    return undefined;
+  }
+
   private handlersAsString(): string | undefined {
-    if (this.handlers) {
-      let s = '{';
+    if (this.handlers && this.handlers.size > 0) {
+      let s = ' @catch {';
       this.handlers.forEach((handler: BasePattern, k: string) => {
-        s = `${s} ${k} ${handler.toString()}\n`;
+        s = `${s}${k} ${handler.toString()} `;
       });
-      return s + '}';
-    } else {
-      return undefined;
+      return s.trimEnd() + '}';
     }
+    return undefined;
   }
+
   hintsAsString(): string {
-    const a = this.aliasesAsString();
-    const h = this.handlersAsString();
-    if (!a && !h) return '';
-    if (a && !h) return a;
-    if (!a && h) return h;
-    return `${a}\n${h}`;
+    // Order matters: @as, then @catch, then @empty (must be last because it's greedy in the grammar)
+    const a = this.aliasesAsString() ?? '';
+    const h = this.handlersAsString() ?? '';
+    const e = this.emptyHandlerAsString() ?? '';
+    return `${a}${h}${e}`;
   }
 
   toString(): string {
@@ -386,12 +398,21 @@ function joinPatternToString(jp: JoinPattern): string {
   return `${jp.type} ${jp.targetEntity} {${jp.conditionLhs}${opr} ${jp.conditionRhs}}`;
 }
 
+export type WhereSpecClausePattern = {
+  lhs: string;
+  op: string;
+  rhs: string;
+};
+
 export class CrudPattern extends BasePattern {
   recordName: string;
   attributes: Array<AttributePattern>;
   relationships: Map<string, CrudPattern[] | CrudPattern> | undefined;
   joins: JoinPattern[];
   into: Map<string, string> | undefined;
+  where: WhereSpecClausePattern[] | undefined;
+  groupBy: string[] | undefined;
+  orderBy: string[] | undefined;
   isQuery: boolean = false;
   isQueryUpdate: boolean = false;
   isCreate: boolean = false;
@@ -521,15 +542,29 @@ export class CrudPattern extends BasePattern {
     return escapeQueryName(this.recordName);
   }
 
-  private intoAsString(): string | undefined {
-    if (this.into) {
-      const ss = new Array<string>();
-      this.into.forEach((attr: string, alias: string) => {
-        ss.push(`${alias} ${attr}`);
-      });
-      return `@into { ${ss.join(',\n')} }`;
-    }
-    return undefined;
+  private intoAsString(): string {
+    const ss = new Array<string>();
+    this.into?.forEach((attr: string, alias: string) => {
+      ss.push(`${alias} ${attr}`);
+    });
+    return `@into { ${ss.join(',\n')} }`;
+  }
+
+  private whereAsString(): string {
+    const ss = new Array<string>();
+    this.where?.forEach((wc: WhereSpecClausePattern) => {
+      if (wc.op == '=') ss.push(`${wc.lhs} ${wc.rhs}`);
+      else ss.push(`${wc.lhs} ${wc.op} ${wc.rhs}`);
+    });
+    return `@where {${ss.join(`,\n`)}}`;
+  }
+
+  private groupByAsString(): string {
+    return `@groupBy(${this.groupBy?.join(', ')})`;
+  }
+
+  private orderByAsString(): string {
+    return `@orderBy(${this.orderBy?.join(', ')})`;
   }
 
   override toString(): string {
@@ -542,10 +577,22 @@ export class CrudPattern extends BasePattern {
       const js = this.joins.map(joinPatternToString);
       s = s.concat(`,\n${js.join(',\n')}`);
     }
-    const ins = this.intoAsString();
-    if (ins) {
-      s = s.concat(`,\n${ins}`);
+    if (this.into) {
+      const ins = this.intoAsString();
+      if (ins) {
+        s = s.concat(`,\n${ins}`);
+      }
+    }
+    if (this.where) {
+      s = s.concat(`,\n${this.whereAsString()}`);
     }
+    if (this.groupBy) {
+      s = s.concat(`,\n${this.groupByAsString()}`);
+    }
+    if (this.orderBy) {
+      s = s.concat(`,\n${this.orderByAsString()}`);
+    }
+
     return s.concat('}', this.hintsAsString());
   }
 }

package/src/runtime/agents/common.ts

@@ -209,7 +209,7 @@ A pattern may execute asynchronously and its eventual result can be handled by p
 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.
 
-Earlier we discussed teh concept of 'between' relationship. Here's the 'CreateEmployee' workflow updated to create the Employee with the his/her Profile attached:
+Earlier we discussed the concept of 'between' relationship. Here's the 'CreateEmployee' workflow updated to create the Employee with the his/her Profile attached:
 
 workflow CreateEmployee {
     {Erp/Employee {firstName CreateEmployee.firstName,

package/src/runtime/api.ts

@@ -5,9 +5,11 @@ import {
 } from './module.js';
 import { getLocalEnv as al_getLocalEnv, setLocalEnv as al_setLocalEnv } from './auth/defs.js';
 import { now } from './util.js';
+import { initDateFns } from './datefns.js';
 
 declare global {
   var agentlang: any | undefined;
+  var dateFns: ReturnType<typeof initDateFns> | undefined;
   function getLocalEnv(k: string, defaultValue?: string): string | undefined;
   function setLocalEnv(k: string, v: string): string;
   function uuid(): string;
@@ -32,6 +34,9 @@ export function initGlobalApi() {
     globalThis.getLocalEnv = al_getLocalEnv;
     globalThis.setLocalEnv = al_setLocalEnv;
 
+    // Expose date-fns functions globally as dateFns.*
+    globalThis.dateFns = initDateFns();
+
     ApiInited = true;
   }
 }

package/src/runtime/datefns.ts

@@ -0,0 +1,112 @@
+import {
+  addDays as _addDays,
+  addWeeks as _addWeeks,
+  addMonths as _addMonths,
+  startOfWeek as _startOfWeek,
+  endOfWeek as _endOfWeek,
+  startOfMonth as _startOfMonth,
+  endOfMonth as _endOfMonth,
+  getISOWeek,
+  format,
+  parse,
+  differenceInDays,
+  differenceInWeeks,
+} from 'date-fns';
+import { formatInTimeZone } from 'date-fns-tz';
+
+/**
+ * Parse a date string as local midnight to avoid timezone day-shift issues.
+ * date-fns operates in local time, so we must parse date-only strings
+ * (YYYY-MM-DD) as local midnight rather than UTC midnight.
+ */
+function toDate(dateStr: string): Date {
+  if (!dateStr.includes('T')) {
+    const [y, m, d] = dateStr.split('-').map(Number);
+    return new Date(y, m - 1, d);
+  }
+  return new Date(dateStr);
+}
+
+function toDateStr(d: Date): string {
+  return format(d, 'yyyy-MM-dd');
+}
+
+function addDays(dateStr: string, days: number): string {
+  return toDateStr(_addDays(toDate(dateStr), days));
+}
+
+function addWeeks(dateStr: string, weeks: number): string {
+  return toDateStr(_addWeeks(toDate(dateStr), weeks));
+}
+
+function addMonths(dateStr: string, months: number): string {
+  return toDateStr(_addMonths(toDate(dateStr), months));
+}
+
+function startOfWeek(dateStr: string): string {
+  return toDateStr(_startOfWeek(toDate(dateStr), { weekStartsOn: 1 }));
+}
+
+function endOfWeek(dateStr: string): string {
+  return toDateStr(_endOfWeek(toDate(dateStr), { weekStartsOn: 1 }));
+}
+
+function startOfMonth(dateStr: string): string {
+  return toDateStr(_startOfMonth(toDate(dateStr)));
+}
+
+function endOfMonth(dateStr: string): string {
+  return toDateStr(_endOfMonth(toDate(dateStr)));
+}
+
+function getWeek(dateStr: string): number {
+  return getISOWeek(toDate(dateStr));
+}
+
+function dayName(dateStr: string): string {
+  return format(toDate(dateStr), 'EEEE');
+}
+
+function formatDate(dateStr: string, fmt: string): string {
+  return format(toDate(dateStr), fmt);
+}
+
+function parseDate(str: string, fmt: string): string {
+  return toDateStr(parse(str, fmt, new Date()));
+}
+
+function diffInDays(dateStr1: string, dateStr2: string): number {
+  return differenceInDays(toDate(dateStr1), toDate(dateStr2));
+}
+
+function diffInWeeks(dateStr1: string, dateStr2: string): number {
+  return differenceInWeeks(toDate(dateStr1), toDate(dateStr2));
+}
+
+function today(): string {
+  return toDateStr(new Date());
+}
+
+function toTimezone(dateStr: string, tz: string): string {
+  return formatInTimeZone(new Date(dateStr), tz, 'yyyy-MM-dd HH:mm:ssXXX');
+}
+
+export function initDateFns() {
+  return {
+    addDays,
+    addWeeks,
+    addMonths,
+    startOfWeek,
+    endOfWeek,
+    startOfMonth,
+    endOfMonth,
+    getWeek,
+    dayName,
+    formatDate,
+    parseDate,
+    diffInDays,
+    diffInWeeks,
+    today,
+    toTimezone,
+  };
+}

package/src/runtime/exec-graph.ts

@@ -304,8 +304,8 @@ export async function executeGraph(execGraph: ExecGraph, env: Environment): Prom
         throw reason;
       } finally {
         if (monitoringEnabled) {
-          if (monitorIncr) env.decrementMonitor();
           env.setMonitorEntryResult(env.getLastResult());
+          if (monitorIncr) env.decrementMonitor();
         }
       }
     }
@@ -425,10 +425,28 @@ export async function executeEvent(
       env.setActiveEvent(eventInstance);
       await executeEventHelper(eventInstance, env);
     } else if (isAgentEventInstance(eventInstance)) {
+      env.setActiveEvent(eventInstance);
+      if (isMonitoringEnabled()) {
+        env.appendEntryToMonitor(
+          `{${eventInstance.getFqName()} {message "${eventInstance.lookup('message')}"}}`
+        );
+      }
       await handleAgentInvocation(eventInstance, env);
+      if (isMonitoringEnabled()) {
+        env.setMonitorEntryResult(env.getLastResult());
+      }
     }
     const r = env.getLastResult();
-    if (continuation) continuation(r);
+    if (continuation) {
+      if (env.getLastPattern() && isAgentEventInstance(eventInstance)) {
+        continuation({
+          result: r.map((res: any) => (res.attributes ? Object.fromEntries(res.attributes) : res)),
+          pattern: env.getLastPattern(),
+        });
+      } else {
+        continuation(r);
+      }
+    }
     return r;
   } catch (err) {
     if (env && env.hasHandlers()) {
@@ -490,6 +508,9 @@ export async function executeEventHelper(eventInstance: Instance, env?: Environm
         );
       }
       await handleAgentInvocation(eventInstance, env);
+      if (isMonitoringEnabled()) {
+        env.setMonitorEntryResult(env.getLastResult());
+      }
     }
     if (isLocalEnv) {
       await env.commitAllTransactions();