agentlang 0.7.8 → 0.7.11

package/src/runtime/loader.ts

@@ -69,6 +69,7 @@ import {
   addAgent,
   fetchModule,
   Retry,
+  addGlobalRetry,
 } from './module.js';
 import {
   asStringLiteralsMap,
@@ -81,6 +82,7 @@ import {
   preprocessRawConfig,
   registerInitFunction,
   rootRef,
+  ScratchModuleName,
 } from './util.js';
 import { getFileSystem, toFsPath, readFile, readdir, exists } from '../utils/fs-utils.js';
 import { URI } from 'vscode-uri';
@@ -348,10 +350,14 @@ async function evaluateConfigPatterns(cfgPats: string): Promise<any> {
   const wf = await parseWorkflow(cfgWf);
   const cfgStmts = new Array<Statement>();
   const initInsts = new Array<Statement>();
+  const deleted = new Set<string>();
   for (let i = 0; i < wf.statements.length; ++i) {
     const stmt: Statement = wf.statements[i];
     if (stmt.pattern.crudMap) {
-      initInsts.push(await makeDeleteAllConfigStatement(stmt.pattern.crudMap));
+      if (!deleted.has(stmt.pattern.crudMap?.name)) {
+        initInsts.push(await makeDeleteAllConfigStatement(stmt.pattern.crudMap));
+        deleted.add(stmt.pattern.crudMap.name);
+      }
       initInsts.push(stmt);
     } else {
       cfgStmts.push(stmt);
@@ -377,20 +383,37 @@ async function evaluateConfigPatterns(cfgPats: string): Promise<any> {
   return undefined;
 }
 
-export async function loadAppConfig(configDir: string): Promise<Config> {
+function isStringContent(content: string): boolean {
+  return content.includes('{');
+}
+
+export async function loadAppConfig(configDirOrContent: string): Promise<Config> {
+  const stringContent = isStringContent(configDirOrContent);
+
   let cfgObj: any = undefined;
-  const fs = await getFileSystem();
-  const alCfgFile = `${configDir}${path.sep}config.al`;
-  if (await fs.exists(alCfgFile)) {
-    const cfgPats = await fs.readFile(alCfgFile);
-    if (canParse(cfgPats)) {
-      cfgObj = await evaluateConfigPatterns(cfgPats);
+
+  if (!stringContent) {
+    const fs = await getFileSystem();
+    const alCfgFile = `${configDirOrContent}${path.sep}config.al`;
+    if (await fs.exists(alCfgFile)) {
+      configDirOrContent = await fs.readFile(alCfgFile);
     }
   }
+
+  if (canParse(configDirOrContent)) {
+    cfgObj = await evaluateConfigPatterns(configDirOrContent);
+  }
+
   try {
-    const cfg = cfgObj
+    let cfg = cfgObj
       ? await configFromObject(cfgObj)
-      : await loadRawConfig(`${configDir}${path.sep}app.config.json`);
+      : await loadRawConfig(`${configDirOrContent}${path.sep}app.config.json`);
+
+    const envAppConfig = typeof process !== 'undefined' ? process.env.APP_CONFIG : undefined;
+    if (envAppConfig) {
+      const envConfig = JSON.parse(envAppConfig);
+      cfg = { ...cfg, ...envConfig };
+    }
     return setAppConfig(cfg);
   } catch (err: any) {
     if (err instanceof z.ZodError) {
@@ -891,7 +914,7 @@ function addFlowDefinition(def: FlowDefinition, moduleName: string) {
       f = sdef;
     }
   }
-  m.addFlow(def.name, f);
+  m.addFlow(def.name, def);
   registerFlow(`${moduleName}/${def.name}`, f);
 }
 
@@ -1161,6 +1184,7 @@ export async function internModule(
   // Process imports sequentially to ensure all JS modules are loaded before definitions
   for (const imp of module.imports as Import[]) {
     await importModule(imp.path, imp.name, moduleFileName);
+    r.addImport({ name: imp.name, path: imp.path });
   }
   for (let i = 0; i < module.defs.length; ++i) {
     const def = module.defs[i];
@@ -1186,31 +1210,57 @@ export async function loadRawConfig(
   }
 }
 
-function filterConfigEntityInstances(rawConfig: any): [any, Map<string, any>] {
-  const cfg = new Map<string, any>();
-  const insts = new Map<string, any>();
-  Object.entries(rawConfig).forEach(([key, value]: [string, any]) => {
-    if (isFqName(key)) {
-      insts.set(key, value);
-    } else {
-      cfg.set(key, value);
-    }
+function filterConfigEntityInstances(rawConfig: any): [any, Array<any>] {
+  let cfg: any = undefined;
+  const insts = new Array<any>();
+  const oldFormat = Object.keys(rawConfig).some((k: string) => {
+    return k === 'store' || k === 'service';
   });
-  return [Object.fromEntries(cfg), insts];
+  const newFormat = !oldFormat;
+  if (newFormat) {
+    Object.entries(rawConfig).forEach(([key, value]: [string, any]) => {
+      if (key === 'agentlang') {
+        cfg = value;
+      } else {
+        if (value instanceof Array) {
+          value.forEach((v: any) => {
+            insts.push(v);
+          });
+        } else {
+          insts.push(value);
+        }
+      }
+    });
+    if (cfg === undefined) cfg = {};
+    return [cfg, insts];
+  } else {
+    return [rawConfig, insts];
+  }
 }
 
 async function configFromObject(cfgObj: any, validate: boolean = true): Promise<any> {
   const rawConfig = preprocessRawConfig(cfgObj);
-  if (validate) {
+  if (validate && rawConfig) {
     const [cfg, insts] = filterConfigEntityInstances(rawConfig);
     const pats = new Array<string>();
-    insts.forEach((v: any, k: string) => {
-      pats.push(`{${k} ${objectAsString(v)}}`);
+    insts.forEach((v: any) => {
+      const n = Object.keys(v)[0];
+      const attrs = v[n];
+      pats.push(`{${n} ${objectAsString(attrs)}}`);
     });
     if (pats.length > 0) {
       await evaluateConfigPatterns(pats.join('\n'));
     }
-    return ConfigSchema.parse(cfg);
+    const result = ConfigSchema.parse(cfg);
+    cfg.retry?.forEach((r: any) => {
+      const retry: Retry = new Retry(r.name, ScratchModuleName, r.attempts)
+        .setBackoffDelay(r.backoff.delay)
+        .setBackoffFactor(r.backoff.factor)
+        .setBackoffStrategy(r.backoff.strategy[0])
+        .setBackoffMagnitude(r.backoff.magnitude);
+      addGlobalRetry(retry);
+    });
+    return result;
   }
   return rawConfig;
 }

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)],