agentlang 0.6.4 → 0.6.6

package/src/runtime/module.ts

@@ -47,6 +47,7 @@ import {
   forceAsFqName,
   validateIdFormat,
   nameContainsSepEscape,
+  registerInitFunction,
 } from './util.js';
 import { parseStatement } from '../language/parser.js';
 import { ActiveSessionInfo, AdminSession } from './auth/defs.js';
@@ -73,6 +74,8 @@ import {
   removeAgentResponseSchema,
   removeAgentScenarios,
 } from './agents/common.js';
+import { Environment } from './interpreter.js';
+import { isNode } from '../utils/fs-utils.js';
 
 export class ModuleEntry {
   name: string;
@@ -1117,6 +1120,25 @@ ${attrs.join(',\n')}
   }
 }
 
+const SysAttr_Created = '__created';
+const SysAttr_LastModified = '__last_modified';
+const SysAttr_CreatedBy = '__created_by';
+const SysAttr_LastModifiedBy = '__last_modified_by';
+
+const SysAttr_CreatedSpec: AttributeSpec = asSystemAttribute({
+  type: 'DateTime',
+  properties: new Map<string, any>().set('default', 'now()'),
+});
+
+const SysAttr_LastModifiedSpec = SysAttr_CreatedSpec;
+
+const SysAttr_CreatedBySpec: AttributeSpec = asSystemAttribute({
+  type: 'String',
+  properties: new Map<string, any>().set('optional', true),
+});
+
+const SysAttr_LastModifiedBySpec = SysAttr_CreatedBySpec;
+
 export class Entity extends Record {
   override type: RecordType = RecordType.ENTITY;
 
@@ -1127,6 +1149,16 @@ export class Entity extends Record {
     parentEntryName?: string
   ) {
     super(name, moduleName, scm, parentEntryName);
+    this.addMetaAttributes();
+  }
+
+  private addMetaAttributes(): Entity {
+    this.schema
+      .set(SysAttr_Created, SysAttr_CreatedSpec)
+      .set(SysAttr_CreatedBy, SysAttr_CreatedBySpec)
+      .set(SysAttr_LastModified, SysAttr_LastModifiedSpec)
+      .set(SysAttr_LastModifiedBy, SysAttr_LastModifiedBySpec);
+    return this;
   }
 
   setRbacSpecifications(rbac: RbacSpecification[]): Entity {
@@ -2255,6 +2287,17 @@ export class Module {
     return false;
   }
 
+  removeEvent(name: string): boolean {
+    if (this.isEvent(name)) {
+      const r: boolean = this.removeEntry(name);
+      if (r) {
+        this.removeEntry(asWorkflowName(name));
+        return r;
+      }
+    }
+    return false;
+  }
+
   private getEntriesOfType(t: RecordType): ModuleEntry[] {
     return this.entries.filter((v: ModuleEntry) => {
       const r: Record = v as Record;
@@ -2413,7 +2456,26 @@ export class Module {
   }
 }
 
-const moduleDb = new Map<string, Module>();
+declare global {
+  var al_moduleDb: Map<string, Module> | undefined;
+}
+
+let browserModuleDb: Map<string, Module> | undefined;
+
+const getModuleDb = function (): Map<string, Module> {
+  if (isNode()) {
+    if (globalThis.al_moduleDb === undefined) {
+      globalThis.al_moduleDb = new Map<string, Module>();
+    }
+    return globalThis.al_moduleDb;
+  } else {
+    if (browserModuleDb === undefined) {
+      browserModuleDb = new Map<string, Module>();
+    }
+    return browserModuleDb;
+  }
+};
+
 let activeModule: string = '';
 
 export function getActiveModuleName() {
@@ -2422,12 +2484,13 @@ export function getActiveModuleName() {
 
 export function addModule(name: string): Module {
   const mod: Module = new Module(name);
-  moduleDb.set(name, mod);
+  getModuleDb().set(name, mod);
   activeModule = name;
   return mod;
 }
 
 export function removeModule(name: string): boolean {
+  const moduleDb = getModuleDb();
   if (moduleDb.has(name)) {
     moduleDb.delete(name);
     return true;
@@ -2439,13 +2502,13 @@ addModule(DefaultModuleName);
 addRecord('env', DefaultModuleName);
 
 export function getModuleNames(): string[] {
-  const ks: Iterable<string> = moduleDb.keys();
+  const ks: Iterable<string> = getModuleDb().keys();
   return Array.from(ks);
 }
 
 export function getUserModuleNames(): string[] {
   const result: Array<string> = new Array<string>();
-  Array.from(moduleDb.keys()).forEach((n: string) => {
+  Array.from(getModuleDb().keys()).forEach((n: string) => {
     if (!DefaultModules.has(n)) {
       result.push(n);
     }
@@ -2454,11 +2517,11 @@ export function getUserModuleNames(): string[] {
 }
 
 export function isModule(name: string): boolean {
-  return moduleDb.has(name);
+  return getModuleDb().has(name);
 }
 
 export function fetchModule(moduleName: string): Module {
-  const module: Module | undefined = moduleDb.get(moduleName);
+  const module: Module | undefined = getModuleDb().get(moduleName);
   if (module === undefined) {
     throw new Error(`Module not found - ${moduleName}`);
   }
@@ -2466,7 +2529,7 @@ export function fetchModule(moduleName: string): Module {
 }
 
 export function allModuleNames(): string[] {
-  return [...moduleDb.keys()];
+  return [...getModuleDb().keys()];
 }
 
 export function fetchModuleEntry(entryName: string, moduleName: string): ModuleEntry {
@@ -2829,21 +2892,23 @@ export function addWorkflow(
   }
   if (!statements) statements = new Array<Statement>();
   if (hdr) {
-    const eventFqName = makeFqName(moduleName, name);
-    const entityDef = getEntityDef(hdr.name, moduleName);
-    if (hdr.tag == '@after') {
-      entityDef?.addAfterTrigger({
-        on: hdr.prefix,
-        event: eventFqName,
-        async: false,
-      });
-    } else {
-      entityDef?.addBeforeTrigger({
-        on: hdr.prefix,
-        event: eventFqName,
-        async: false,
-      });
-    }
+    registerInitFunction(() => {
+      const eventFqName = makeFqName(moduleName, name);
+      const entityDef = getEntityDef(hdr.name, moduleName);
+      if (hdr.tag == '@after') {
+        entityDef?.addAfterTrigger({
+          on: hdr.prefix,
+          event: eventFqName,
+          async: false,
+        });
+      } else {
+        entityDef?.addBeforeTrigger({
+          on: hdr.prefix,
+          event: eventFqName,
+          async: false,
+        });
+      }
+    });
   }
   return module.addEntry(
     new Workflow(asWorkflowName(name), statements, moduleName, hdr ? true : false)
@@ -3178,14 +3243,7 @@ export function removeWorkflow(name: string, moduleName = activeModule): boolean
 
 export function removeEvent(name: string, moduleName = activeModule): boolean {
   const module: Module = fetchModule(moduleName);
-  if (module.isEvent(name)) {
-    const r: boolean = module.removeEntry(name);
-    if (r) {
-      module.removeEntry(asWorkflowName(name));
-      return r;
-    }
-  }
-  return false;
+  return module.removeEvent(name);
 }
 
 function getAttributeSpec(attrsSpec: RecordSchema, attrName: string): AttributeSpec {
@@ -3264,7 +3322,7 @@ export class Instance {
   queryAttributeValues: InstanceAttributes | undefined;
   relatedInstances: Map<string, Instance[]> | undefined;
   private contextData: Map<string, any> | undefined;
-  private id: string;
+  private ___id: string;
 
   constructor(
     record: Record,
@@ -3274,7 +3332,7 @@ export class Instance {
     queryAttributes?: InstanceAttributes,
     queryAttributeValues?: InstanceAttributes
   ) {
-    this.id = crypto.randomUUID();
+    this.___id = crypto.randomUUID();
     this.record = record;
     this.name = name;
     this.moduleName = moduleName;
@@ -3297,6 +3355,10 @@ export class Instance {
     );
   }
 
+  static IsInstance(obj: any): boolean {
+    return obj instanceof Instance || (obj instanceof Object && obj.___id);
+  }
+
   static clone(inst: Instance): Instance {
     const attrs = newInstanceAttributes();
     inst.attributes.forEach((v: any, k: string) => {
@@ -3306,7 +3368,16 @@ export class Instance {
   }
 
   getId(): string {
-    return this.id;
+    return this.___id;
+  }
+
+  metaAttributeValues(): any {
+    return {
+      created: this.lookup(SysAttr_Created),
+      createdBy: this.lookup(SysAttr_CreatedBy),
+      lastModified: this.lookup(SysAttr_LastModified),
+      lastModifiedBy: this.lookup(SysAttr_LastModifiedBy),
+    };
   }
 
   normalizeAttributes(attrs: InstanceAttributes): InstanceAttributes {
@@ -3411,7 +3482,7 @@ export class Instance {
   }
 
   static asSerializableValue(v: any, forSerialization: boolean): any {
-    if (v instanceof Instance) {
+    if (Instance.IsInstance(v)) {
       const inst = v as Instance;
       return forSerialization ? inst.asSerializableObject() : inst.asObject();
     } else if (v instanceof Object) {
@@ -3488,10 +3559,10 @@ export class Instance {
     if (relInsts === undefined) {
       relInsts = new Array<Instance>();
     }
-    if (insts instanceof Instance) {
-      relInsts.push(insts);
+    if (Instance.IsInstance(insts)) {
+      relInsts.push(insts as Instance);
     } else {
-      insts.forEach((inst: Instance) => {
+      (insts as Instance[]).forEach((inst: Instance) => {
         relInsts.push(inst);
       });
     }
@@ -3591,7 +3662,7 @@ export class Instance {
 export function maybeInstanceAsString(result: any): string {
   if (!isString(result)) {
     try {
-      if (result instanceof Instance) {
+      if (Instance.IsInstance(result)) {
         const inst = result as Instance;
         return JSON.stringify(inst.asSerializableObject());
       } else if (result instanceof Array) {
@@ -3729,7 +3800,7 @@ export function isRecordInstance(inst: Instance): boolean {
 
 export function getAllModuleEntries(f: Function): Map<string, string[]> {
   const result: Map<string, string[]> = new Map<string, string[]>();
-  moduleDb.forEach((module: Module, k: string) => {
+  getModuleDb().forEach((module: Module, k: string) => {
     result.set(
       k,
       f(module).map((me: ModuleEntry) => {
@@ -3779,16 +3850,9 @@ export function getBetweenInstanceNodeValues(inst: Instance): BetweenInstanceNod
   };
 }
 
-export function isInstance(obj: any): boolean {
-  if (obj) {
-    return obj instanceof Instance;
-  }
-  return false;
-}
-
 export function isInstanceOfType(obj: any, fqName: string): boolean {
   if (obj) {
-    return isInstance(obj) && fqName == (obj as Instance).getFqName();
+    return Instance.IsInstance(obj) && fqName == (obj as Instance).getFqName();
   }
   return false;
 }
@@ -3799,7 +3863,7 @@ export function assertInstance(obj: any) {
       throw new Error(`Empty instances`);
     }
     obj.forEach(assertInstance);
-  } else if (!(obj instanceof Instance)) {
+  } else if (!Instance.IsInstance(obj)) {
     throw new Error(`${obj} is not an Instance`);
   }
 }
@@ -3929,3 +3993,15 @@ export function getAttributeNames(entityFqName: string): Array<string> {
   const scm = fetchModule(parts.getModuleName()).getRecord(parts.getEntryName()).schema;
   return [...scm.keys()];
 }
+
+export function maybeSetMetaAttributes(
+  attrs: InstanceAttributes,
+  env: Environment,
+  inUpdateMode: boolean = false
+) {
+  const user = env.getActiveUser();
+  attrs.set(SysAttr_LastModified, now()).set(SysAttr_LastModifiedBy, user);
+  if (!inUpdateMode && attrs.get(SysAttr_CreatedBy) === undefined) {
+    attrs.set(SysAttr_CreatedBy, user);
+  }
+}

package/src/runtime/modules/ai.ts

@@ -377,8 +377,8 @@ Only return a pure JSON object with no extra text, annotations etc.`;
     if (obj === null || obj === undefined) return this;
     let r: Instance | Instance[] | undefined = undefined;
     if (
-      obj instanceof Instance ||
-      (obj instanceof Array && obj.length > 0 && obj[0] instanceof Instance)
+      Instance.IsInstance(obj) ||
+      (obj instanceof Array && obj.length > 0 && Instance.IsInstance(obj[0]))
     ) {
       r = obj;
     } else {
@@ -394,8 +394,9 @@ Only return a pure JSON object with no extra text, annotations etc.`;
       });
       n = r[0].getFqName();
     } else {
-      data = extractScratchData(scratchNames, r);
-      n = r.getFqName();
+      const i = r as Instance;
+      data = extractScratchData(scratchNames, i);
+      n = i.getFqName();
     }
     if (data) env.addToScratchPad(n, data);
     return this;

package/src/runtime/modules/auth.ts

@@ -44,6 +44,7 @@ entity User {
 
 workflow AfterDeleteUser {
   {RemoveUserSession {id AfterDeleteUser.User.id}}
+  await Auth.deleteUser(AfterDeleteUser.User.id, AfterDeleteUser.User.email)
 }
 
 @public workflow CreateUser {
@@ -569,6 +570,41 @@ export async function activateUser(userId: string, env: Environment): Promise<Re
   }
 }
 
+export async function deleteUser(userId: string, email: string, env: Environment): Promise<Result> {
+  const needCommit = env ? false : true;
+  env = env ? env : new Environment();
+  const f = async () => {
+    try {
+      if (email) {
+        try {
+          await fetchAuthImpl().deleteUser(email, env);
+        } catch (err: any) {
+          // If user doesn't exist in Cognito, log warning but continue with local deletion
+          if (err.message && err.message.includes('not found')) {
+            logger.warn(`User ${email} not found in Cognito, continuing with local deletion`);
+          } else {
+            logger.error(`Failed to delete user ${email} from Cognito: ${err.message}`);
+            throw err;
+          }
+        }
+      }
+
+      return {
+        status: 'ok',
+        message: 'User deleted successfully',
+      };
+    } catch (err: any) {
+      logger.error(`Failed to delete user ${userId}: ${err.message}`);
+      throw err;
+    }
+  };
+  if (needCommit) {
+    return await env.callInTransaction(f);
+  } else {
+    return await f();
+  }
+}
+
 export async function updateUserLastLogin(id: string, env: Environment): Promise<Result> {
   return await evalEvent(
     'UpdateUserLastLogin',

package/src/runtime/monitor.ts

@@ -1,4 +1,4 @@
-import { Instance, isAgentEventInstance, isInstance } from './module.js';
+import { Instance, isAgentEventInstance } from './module.js';
 import { disableInternalMonitoring, enableInternalMonitoring } from './state.js';
 
 export class MonitorEntry {
@@ -104,7 +104,7 @@ export class MonitorEntry {
   }
 
   private static resultAsObject(result: any): object {
-    if (result instanceof Instance) return result.asSerializableObject();
+    if (Instance.IsInstance(result)) return result.asSerializableObject();
     else if (result instanceof Array)
       return result.map((v: any) => {
         return MonitorEntry.resultAsObject(v);
@@ -327,11 +327,11 @@ export class Monitor {
     r.timestamp = this.timestamp;
     if (this.flowResult !== undefined) {
       let fr = this.flowResult;
-      if (fr instanceof Array && isInstance(fr[0])) {
+      if (fr instanceof Array && Instance.IsInstance(fr[0])) {
         fr = fr.map((v: any) => {
           return v.asSerializableObject();
         });
-      } else if (isInstance(fr)) {
+      } else if (Instance.IsInstance(fr)) {
         fr = fr.asSerializableObject();
       }
       r.flowResult = fr;