agentlang 0.7.9 → 0.7.11

package/src/runtime/module.ts

@@ -20,6 +20,8 @@ import {
   RbacSpecEntries,
   RbacOpr,
   WorkflowHeader,
+  FlowDefinition,
+  FlowEntry,
 } from '../language/generated/ast.js';
 import {
   Path,
@@ -75,7 +77,7 @@ import {
   removeAgentResponseSchema,
   removeAgentScenarios,
 } from './agents/common.js';
-import { Environment } from './interpreter.js';
+import { AggregateFunctionCall, Environment } from './interpreter.js';
 import { isNode } from '../utils/fs-utils.js';
 
 export class ModuleEntry {
@@ -208,7 +210,7 @@ function attributePropertyValueToString(
     });
     return ss.join(',');
   } else if (propName == 'default') {
-    if (isTextualType(attrType) && propValue != 'now()' && propValue != 'uuid()') {
+    if (isTextualType(attrType) && !defaultValueIsFunctionCall(propValue)) {
       return `"${propValue}"`;
     }
   } else if (propName == 'comment') {
@@ -433,6 +435,37 @@ export class Record extends ModuleEntry {
     return this;
   }
 
+  public getSecretAttributes(): Array<string> {
+    const result = new Array<string>();
+    this.schema.forEach((spec: AttributeSpec, n: string) => {
+      if (spec.properties?.get('secret') === true) {
+        result.push(n);
+      }
+    });
+    return result;
+  }
+
+  private static WriteOnlyAttributes = new Map<string, Array<string>>();
+
+  public getWriteOnlyAttributes(): Array<string> | undefined {
+    const fqn = this.getFqName();
+    const cachedResult = Record.WriteOnlyAttributes.get(fqn);
+    if (cachedResult !== undefined) {
+      if (cachedResult.length === 0) return undefined;
+      return cachedResult;
+    } else {
+      const result = new Array<string>();
+      this.schema.forEach((spec: AttributeSpec, n: string) => {
+        if (spec.properties?.get('writeonly') === true) {
+          result.push(n);
+        }
+      });
+      const finalResult = result.concat(this.getSecretAttributes());
+      Record.WriteOnlyAttributes.set(fqn, finalResult);
+      return finalResult;
+    }
+  }
+
   getCompositeUniqueAttributes(): Array<string> | undefined {
     return this.compositeUqAttributes;
   }
@@ -641,18 +674,27 @@ export class Record extends ModuleEntry {
     return s.concat('\n{', scms, '\n}\n');
   }
 
+  private userAttrsSchema: RecordSchema | undefined;
+
   getUserAttributes(): RecordSchema {
-    const recSchema: RecordSchema = newRecordSchema();
-    this.schema.forEach((attrSpec: AttributeSpec, n: string) => {
-      if (!isSystemAttribute(attrSpec)) {
-        recSchema.set(n, attrSpec);
-      }
-    });
-    return recSchema;
+    if (this.userAttrsSchema === undefined) {
+      this.userAttrsSchema = newRecordSchema();
+      this.schema.forEach((attrSpec: AttributeSpec, n: string) => {
+        if (!isSystemAttribute(attrSpec)) {
+          this.userAttrsSchema?.set(n, attrSpec);
+        }
+      });
+    }
+    return this.userAttrsSchema;
   }
 
-  getUserAttributeNames(): string[] {
-    return [...this.getUserAttributes().keys()];
+  private userAttrNames: Set<string> | undefined;
+
+  getUserAttributeNames(): Set<string> {
+    if (this.userAttrNames === undefined) {
+      this.userAttrNames = new Set([...this.getUserAttributes().keys()]);
+    }
+    return this.userAttrNames;
   }
 }
 
@@ -1592,18 +1634,21 @@ export type FlowGraphNode = {
   next: string[];
 };
 
+function splitFlowSteps(flow: FlowDefinition): string[] {
+  const steps = new Array<string>();
+  flow.body?.entries.forEach((fe: FlowEntry) => {
+    steps.push(fe.$cstNode?.text || '');
+  });
+  return steps;
+}
+
 export class Flow extends ModuleEntry {
   flowSteps: string[];
 
-  constructor(name: string, moduleName: string, flow?: string) {
+  constructor(name: string, moduleName: string, flow?: FlowDefinition) {
     super(name, moduleName);
-    this.flowSteps = new Array<string>();
-    flow?.split('\n').forEach((step: string) => {
-      const s = step.trim();
-      if (s.length > 0) {
-        this.flowSteps.push(s);
-      }
-    });
+    if (flow) this.flowSteps = splitFlowSteps(flow);
+    else this.flowSteps = new Array<string>();
   }
 
   getFlow(): string {
@@ -1629,10 +1674,11 @@ export class Flow extends ModuleEntry {
     return this.flowSteps.length;
   }
 
-  toGraph(): FlowGraphNode[] {
+  async toGraph(): Promise<FlowGraphNode[]> {
     const result = new Array<FlowGraphNode>();
-    this.flowSteps.forEach((s: string) => {
-      const fp = FlowStepPattern.Parse(s);
+    for (let i = 0; i < this.flowSteps.length; ++i) {
+      const s = this.flowSteps[i];
+      const fp = await FlowStepPattern.Parse(s);
       if (fp.condition) {
         const orig = result.find((v: FlowGraphNode) => {
           return v.label == fp.first;
@@ -1657,7 +1703,7 @@ export class Flow extends ModuleEntry {
           next: [fp.next],
         });
       }
-    });
+    }
     return result;
   }
 
@@ -1801,6 +1847,11 @@ export class Retry extends ModuleEntry {
     };
   }
 
+  setBackoffStrategy(s: BackoffStrategy): Retry {
+    this.backoff.strategy = s;
+    return this;
+  }
+
   setExponentialBackoff(): Retry {
     this.backoff.strategy = 'e';
     return this;
@@ -1835,6 +1886,17 @@ export class Retry extends ModuleEntry {
     return this;
   }
 
+  setBackoffMagnitude(m: string): Retry {
+    if (m[0] === 's') {
+      this.backoff.magnitude = 's';
+    } else if (m.startsWith('milli')) {
+      this.backoff.magnitude = 'ms';
+    } else {
+      this.backoff.magnitude = 'm';
+    }
+    return this;
+  }
+
   setBackoffMagnitudeAsMilliseconds(): Retry {
     this.backoff.magnitude = 'ms';
     return this;
@@ -1995,9 +2057,15 @@ export function isEmptyWorkflow(wf: Workflow): boolean {
   return wf == EmptyWorkflow;
 }
 
+export type ModuleImportEntry = {
+  path: string;
+  name: string;
+};
+
 export class Module {
   name: string;
   entries: ModuleEntry[];
+  imports: ModuleImportEntry[] | undefined;
 
   constructor(name: string) {
     this.name = name;
@@ -2009,6 +2077,21 @@ export class Module {
     return entry;
   }
 
+  addImport(entry: ModuleImportEntry): Module {
+    if (this.imports === undefined) {
+      this.imports = new Array<ModuleImportEntry>();
+    }
+    this.imports?.push(entry);
+    return this;
+  }
+
+  removeImportAt(index: number): Module {
+    if (index >= 0) {
+      this.imports?.splice(index, 1);
+    }
+    return this;
+  }
+
   getConfigEntity(): Entity | undefined {
     return this.getEntityEntries().find((e: Entity) => {
       return e.isConfigEntity();
@@ -2031,8 +2114,8 @@ export class Module {
     return this.removeEntry(Agent.EscapeName(agentName));
   }
 
-  addFlow(name: string, flowString?: string): Flow {
-    const flow: Flow = new Flow(Flow.asFlowName(name), this.name, flowString);
+  addFlow(name: string, flowDef?: FlowDefinition): Flow {
+    const flow: Flow = new Flow(Flow.asFlowName(name), this.name, flowDef);
     this.addEntry(flow);
     return flow;
   }
@@ -2434,6 +2517,14 @@ export class Module {
     return names;
   }
 
+  getBetweenRelationshipNames(): string[] {
+    const names: string[] = [];
+    this.getRelationshipEntries().forEach((re: Relationship) => {
+      if (re.isBetween()) names.push(re.name);
+    });
+    return names;
+  }
+
   isContainsRelationship(entryName: string): boolean {
     if (this.hasEntry(entryName)) {
       const entry: ModuleEntry = this.getEntry(entryName);
@@ -2450,6 +2541,17 @@ export class Module {
     return false;
   }
 
+  private importsAsString(): string {
+    if (this.imports !== undefined) {
+      const ss = new Array<string>();
+      this.imports.forEach((me: ModuleImportEntry) => {
+        ss.push(`import "${me.path}" @as ${me.name}`);
+      });
+      return `\n${ss.join('\n')}\n`;
+    }
+    return '';
+  }
+
   toString(): string {
     const ss: Array<string> = [];
     this.entries.forEach((me: ModuleEntry) => {
@@ -2458,8 +2560,27 @@ export class Module {
       }
       ss.push(me.toString());
     });
-    return `module ${this.name}\n\n${ss.join('\n')}`;
+    return `module ${this.name}\n${this.importsAsString()}\n${ss.join('\n')}`;
+  }
+}
+
+let GlobalRetries: Array<Retry> | undefined = undefined;
+
+export function addGlobalRetry(r: Retry): Retry {
+  if (GlobalRetries === undefined) {
+    GlobalRetries = new Array<Retry>();
+  }
+  GlobalRetries?.push(r);
+  return r;
+}
+
+export function getGlobalRetry(name: string): Retry | undefined {
+  if (GlobalRetries !== undefined) {
+    return GlobalRetries.find((r: Retry) => {
+      return r.name === name;
+    });
   }
+  return undefined;
 }
 
 declare global {
@@ -2587,6 +2708,8 @@ export const propertyNames = new Set([
   '@fk',
   '@ref',
   '@readonly',
+  '@writeonly',
+  '@secret',
   '@enum',
   '@oneof',
   '@comment',
@@ -2655,7 +2778,7 @@ export function defaultAttributes(schema: RecordSchema): Map<string, any> {
 export function passwordAttributes(schema: RecordSchema): Set<string> | undefined {
   let result: Set<string> | undefined = undefined;
   schema.forEach((v: AttributeSpec, k: string) => {
-    if (v.type == 'Password') {
+    if (v.type == 'Password' || v.properties?.get('secret') === true) {
       if (result === undefined) {
         result = new Set<string>();
       }
@@ -3336,6 +3459,10 @@ export class Instance {
   queryAttributes: InstanceAttributes | undefined;
   queryAttributeValues: InstanceAttributes | undefined;
   relatedInstances: Map<string, Instance[]> | undefined;
+  aggregates: Map<string, AggregateFunctionCall> | undefined;
+  groupBy: string[] | undefined;
+  orderBy: string[] | undefined;
+  orderByDesc: boolean = false;
   private contextData: Map<string, any> | undefined;
   private ___id: string;
 
@@ -3432,6 +3559,22 @@ export class Instance {
     return this.lookup(PathAttributeName);
   }
 
+  setAggregates(aggregates: Map<string, AggregateFunctionCall>): Instance {
+    this.aggregates = aggregates;
+    return this;
+  }
+
+  setGroupBy(n: string[]): Instance {
+    this.groupBy = n;
+    return this;
+  }
+
+  setOrderBy(n: string[], desc: boolean = false): Instance {
+    this.orderBy = n;
+    this.orderByDesc = desc;
+    return this;
+  }
+
   asSerializableObject(): object {
     const obj: any = {
       AL_INSTANCE: true,
@@ -3519,6 +3662,15 @@ export class Instance {
     return Object.fromEntries(attrs);
   }
 
+  userAttributesAsObject(forSerialization: boolean = false): object {
+    const attrs = newInstanceAttributes();
+    const userAttrNames = this.getAllUserAttributeNames();
+    this.attributes.forEach((v: any, k: string) => {
+      if (userAttrNames.has(k)) attrs.set(k, Instance.asSerializableValue(v, forSerialization));
+    });
+    return Object.fromEntries(attrs);
+  }
+
   static stringifyObjects(attributes: InstanceAttributes): object {
     const attrs = newInstanceAttributes();
     attributes.forEach((v: any, k: string) => {
@@ -3549,6 +3701,10 @@ export class Instance {
     return {};
   }
 
+  getQueryValue(k: string): any {
+    return this.queryAttributeValues?.get(k);
+  }
+
   addQuery(attrName: string, op: string = '=', attrVal: any = undefined) {
     if (this.queryAttributes === undefined) this.queryAttributes = newInstanceAttributes();
     this.queryAttributes.set(attrName, op);
@@ -3610,7 +3766,7 @@ export class Instance {
     return undefined;
   }
 
-  getAllUserAttributeNames(): string[] {
+  getAllUserAttributeNames(): Set<string> {
     return this.record.getUserAttributeNames();
   }
 
@@ -3743,6 +3899,10 @@ export function findIdAttribute(inst: Instance): AttributeEntry | undefined {
   return undefined;
 }
 
+function defaultValueIsFunctionCall(dv: string): boolean {
+  return dv.endsWith('()');
+}
+
 function maybeSetDefaultAttributeValues(
   schema: RecordSchema,
   attributes: InstanceAttributes
@@ -3752,10 +3912,12 @@ function maybeSetDefaultAttributeValues(
     const cv = attributes.get(k);
     if (cv === undefined || cv === null) {
       if (isString(v)) {
-        if (v == 'uuid()') {
-          v = crypto.randomUUID();
-        } else if (v == 'now()') {
-          v = now();
+        if (defaultValueIsFunctionCall(v)) {
+          try {
+            v = eval(v);
+          } catch {
+            v = (0, eval)(`globalThis.${v}`);
+          }
         }
       }
       attributes.set(k, v);

package/src/runtime/modules/ai.ts

@@ -20,6 +20,7 @@ import {
   Decision,
   fetchModule,
   getDecision,
+  getGlobalRetry,
   Instance,
   instanceToObject,
   isAgent,
@@ -198,11 +199,16 @@ export class AgentInstance {
     if (agent.retry) {
       let n = agent.retry;
       if (!isFqName(n)) {
-        n = `${agent.moduleName}/${n}`;
+        agent.retryObj = getGlobalRetry(n);
+        if (agent.retryObj === undefined) {
+          n = `${agent.moduleName}/${n}`;
+        }
+      }
+      if (agent.retryObj === undefined) {
+        const parts = splitFqName(n);
+        const m = fetchModule(parts[0]);
+        agent.retryObj = m.getRetry(parts[1]);
       }
-      const parts = splitFqName(n);
-      const m = fetchModule(parts[0]);
-      agent.retryObj = m.getRetry(parts[1]);
     }
     return agent;
   }

package/src/runtime/modules/auth.ts

@@ -36,6 +36,7 @@ entity User {
     email Email @unique @indexed,
     firstName String,
     lastName String,
+    profilePicture String @optional,
     lastLoginTime DateTime @default(now()),
     status @enum("Active", "Invited", "Inactive") @default("Active"),
     @rbac [(allow: [read, delete, update, create], where: auth.user = this.id)],

package/src/runtime/modules/core.ts

@@ -8,6 +8,7 @@ import {
   isString,
   restoreSpecialChars,
   makeCoreModuleName,
+  nameToPath,
 } from '../util.js';
 import {
   fetchModule,
@@ -27,7 +28,7 @@ import {
 } from '../interpreter.js';
 import { logger } from '../logger.js';
 import { Statement } from '../../language/generated/ast.js';
-import { parseModule, parseStatements } from '../../language/parser.js';
+import { objectToQueryPattern, parseModule, parseStatements } from '../../language/parser.js';
 import { GenericResolver, Resolver } from '../resolvers/interface.js';
 import {
   FlowSuspensionTag,
@@ -48,7 +49,8 @@ entity timer {
   duration Int,
   unit @enum("millisecond", "second", "minute", "hour") @default("second"),
   trigger String,
-  status @enum("I", "C", "R") @default("I") // Inited, Cancelled, Running
+  repeat Boolean @default(true),
+  status @enum("I", "C", "R") @default("I") @indexed // Inited, Cancelled, Running
 }
 
 entity auditlog {
@@ -56,7 +58,7 @@ entity auditlog {
   action @enum("c", "d", "u"), // Create, Delete, Update
   resource String, // __path__
   timestamp DateTime @default(now()),
-  previous_value Any @optional,
+  diff Any @optional,
   user String,
   token String @optional
 }
@@ -161,6 +163,14 @@ entity Migration {
   ups String @optional,
   downs String @optional
 }
+
+@public event Query {
+  q Any
+}
+
+workflow Query {
+  await Core.doRawQuery(Query.q)
+}
 `;
 
 export const CoreModules: string[] = [];
@@ -183,25 +193,94 @@ export function registerCoreModules() {
   });
 }
 
-export function setTimerRunning(timerInst: Instance) {
-  timerInst.attributes.set('status', 'R');
+function isTimerCancelled(inst: Instance): boolean {
+  return inst.lookup('status') === 'C';
 }
 
-export async function maybeCancelTimer(name: string, timer: NodeJS.Timeout, env: Environment) {
+// If the timer is deleted or its status is set to 'C' (cancelled), then clear the associated timer.
+async function maybeClearTimer(name: string, timer: NodeJS.Timeout, env: Environment) {
   await parseAndEvaluateStatement(`{agentlang/timer {name? "${name}"}}`, undefined, env).then(
     (result: any) => {
-      if (result === null || (result instanceof Array && result.length == 0)) {
+      if (
+        result === null ||
+        (result instanceof Array && (result.length == 0 || isTimerCancelled(result[0])))
+      ) {
         clearInterval(timer);
       }
     }
   );
 }
 
+export function triggerTimer(timerInst: Instance): Instance {
+  const dur = timerInst.lookup('duration');
+  const unit = timerInst.lookup('unit');
+  let millisecs = 0;
+  switch (unit) {
+    case 'millisecond': {
+      millisecs = dur;
+      break;
+    }
+    case 'second': {
+      millisecs = dur * 1000;
+      break;
+    }
+    case 'minute': {
+      millisecs = dur * 60 * 1000;
+      break;
+    }
+    case 'hour': {
+      millisecs = dur * 60 * 60 * 1000;
+      break;
+    }
+  }
+  const eventName = nameToPath(timerInst.lookup('trigger'));
+  const m = eventName.hasModule() ? eventName.getModuleName() : timerInst.moduleName;
+  const n = eventName.getEntryName();
+  const inst = makeInstance(m, n, newInstanceAttributes());
+  const name = timerInst.lookup('name');
+  const repeat = timerInst.lookup('repeat');
+  const timer = setInterval(async () => {
+    const env = new Environment();
+    try {
+      await evaluate(
+        inst,
+        (result: any) => logger.debug(`Timer ${name} ran with result ${result}`),
+        env
+      );
+      await env.commitAllTransactions();
+      if (!repeat) clearInterval(timer);
+      else await maybeClearTimer(name, timer, env);
+    } catch (reason: any) {
+      logger.error(`Timer ${name} raised error: ${reason}`);
+    }
+  }, millisecs);
+  timerInst.attributes.set('status', 'R');
+  return timerInst;
+}
+
+export async function saveTimerStatus(timerInst: Instance): Promise<boolean> {
+  const name = timerInst.lookup('name');
+  const status = timerInst.lookup('status');
+  const env = new Environment();
+  try {
+    await parseAndEvaluateStatement(`{agentlang/timer {name? "${name}", "status": "${status}"}}`);
+    await env.commitAllTransactions();
+  } catch (reason: any) {
+    logger.warn(`Failed to save status of timer ${name} - ${reason}`);
+    return false;
+  }
+  return true;
+}
+
+export async function lookupTimersWithRunningStatus(): Promise<Instance[]> {
+  return await parseAndEvaluateStatement(`{agentlang/timer {status? "R"}}`);
+}
+
 async function addAudit(
   env: Environment,
   action: 'c' | 'd' | 'u',
   resource: string,
-  previuos_value?: Instance
+  diff?: object
 ) {
   const user = env.getActiveUser();
   const token = env.getActiveToken();
@@ -211,7 +290,7 @@ async function addAudit(
     `{agentlang/auditlog {
         action "${action}",
         resource "${resource}",
-        previous_value "${previuos_value ? escapeSpecialChars(JSON.stringify(previuos_value.asObject())) : ''}",
+        diff "${diff ? escapeSpecialChars(JSON.stringify(diff)) : ''}",
         user "${user}",
         token "${token ? token : ''}"
 }}`,
@@ -225,24 +304,16 @@ async function addAudit(
   }
 }
 
-export async function addCreateAudit(resource: string, env: Environment) {
-  await addAudit(env, 'c', resource);
+export async function addCreateAudit(resource: string, env: Environment, init: object) {
+  await addAudit(env, 'c', resource, init);
 }
 
-export async function addDeleteAudit(
-  resource: string,
-  previous_value: Instance | undefined,
-  env: Environment
-) {
-  await addAudit(env, 'd', resource, previous_value);
+export async function addDeleteAudit(resource: string, diff: object | undefined, env: Environment) {
+  await addAudit(env, 'd', resource, diff);
 }
 
-export async function addUpdateAudit(
-  resource: string,
-  previous_value: Instance | undefined,
-  env: Environment
-) {
-  await addAudit(env, 'u', resource, previous_value);
+export async function addUpdateAudit(resource: string, diff: object | undefined, env: Environment) {
+  await addAudit(env, 'u', resource, diff);
 }
 
 export async function createSuspension(
@@ -664,3 +735,8 @@ export function migrationDowns(inst: Instance): string[] | undefined {
   }
   return undefined;
 }
+
+export async function doRawQuery(q: any): Promise<any> {
+  const qs = objectToQueryPattern(q);
+  return await parseAndEvaluateStatement(qs);
+}

package/src/runtime/monitor.ts

@@ -289,6 +289,7 @@ export class Monitor {
 
   decrement(): Monitor {
     if (this.parent !== undefined) {
+      this.parent.totalLatency += this.totalLatency;
       return this.parent;
     }
     return this;

package/src/runtime/resolvers/interface.ts

@@ -33,6 +33,12 @@ export function getSubscriptionEvent(resolverName: string): string | undefined {
   return subscriptionEvents.get(resolverName);
 }
 
+export type WhereClause = {
+  attrName: string;
+  op: string;
+  qval: any;
+};
+
 export class Resolver {
   protected authInfo: ResolverAuthInfo = DefaultAuthInfo;
   protected env: Environment | undefined;
@@ -131,10 +137,11 @@ export class Resolver {
     joinInfo: JoinInfo[],
     intoSpec: Map<string, string>,
     distinct: boolean = false,
-    rawJoinSpec?: JoinSpec
+    rawJoinSpec?: JoinSpec[],
+    whereClauses?: WhereClause[]
   ): Promise<any> {
     return this.notImpl(
-      `queryByJoin(${inst}, ${joinInfo}, ${intoSpec}, ${distinct} ${rawJoinSpec})`
+      `queryByJoin(${inst}, ${joinInfo}, ${intoSpec}, ${distinct}, ${rawJoinSpec}, ${whereClauses})`
     );
   }