agentlang 0.0.3 → 0.0.5

package/src/runtime/resolvers/interface.ts

@@ -1,4 +1,13 @@
-import { Instance, InstanceAttributes, Relationship } from '../module.js';
+import { evaluate } from '../interpreter.js';
+import { logger } from '../logger.js';
+import {
+  Instance,
+  InstanceAttributes,
+  makeInstance,
+  newInstanceAttributes,
+  Relationship,
+} from '../module.js';
+import { splitFqName } from '../util.js';
 
 export class ResolverAuthInfo {
   userId: string;
@@ -24,6 +33,16 @@ export type JoinInfo = {
   subJoins: JoinInfo[] | undefined;
 };
 
+const subscriptionEvents: Map<string, string> = new Map<string, string>();
+
+export function setSubscriptionEvent(fqEventName: string, resolverName: string) {
+  subscriptionEvents.set(resolverName, fqEventName);
+}
+
+export function getSubscriptionEvent(resolverName: string): string | undefined {
+  return subscriptionEvents.get(resolverName);
+}
+
 export class Resolver {
   protected authInfo: ResolverAuthInfo = DefaultAuthInfo;
   protected userData: any;
@@ -31,6 +50,10 @@ export class Resolver {
 
   static Default = new Resolver();
 
+  constructor(name?: string) {
+    if (name) this.name = name;
+  }
+
   public setAuthInfo(authInfo: ResolverAuthInfo): Resolver {
     this.authInfo = authInfo;
     return this;
@@ -49,8 +72,8 @@ export class Resolver {
     return this.name;
   }
 
-  private notImpl(method: string) {
-    throw new Error(`Resolver method ${method} not implemented`);
+  protected notImpl(method: string) {
+    logger.warn(`Method ${method} not implemented in resolver ${this.name}`);
   }
 
   public onSetPath(moduleName: string, entryName: string): any {
@@ -147,14 +170,126 @@ export class Resolver {
 
   // Return a transactionId
   public async startTransaction(): Promise<any> {
-    return this.notImpl('startTransaction()');
+    this.notImpl('startTransaction()');
+    return 1;
   }
 
   public async commitTransaction(txnId: string): Promise<any> {
     return this.notImpl(`commitTransaction(${txnId})`);
   }
 
-  public async rollbackTransaction(txtIn: string): Promise<any> {
-    return this.notImpl(`rollbackTransaction(${txtIn})`);
+  public async rollbackTransaction(txnId: string): Promise<any> {
+    return this.notImpl(`rollbackTransaction(${txnId})`);
+  }
+
+  public async subscribe(): Promise<any> {
+    return undefined;
+  }
+
+  public async onSubscription(result: any): Promise<any> {
+    if (result != undefined) {
+      const eventName = getSubscriptionEvent(this.name);
+      if (eventName) {
+        const path = splitFqName(eventName);
+        const inst = makeInstance(
+          path.getModuleName(),
+          path.getEntryName(),
+          newInstanceAttributes().set('data', result)
+        );
+        return await evaluate(inst);
+      }
+    }
+  }
+}
+
+type MaybeFunction = Function | undefined;
+
+export type GenericResolverMethods = {
+  create: MaybeFunction;
+  upsert: MaybeFunction;
+  update: MaybeFunction;
+  query: MaybeFunction;
+  delete: MaybeFunction;
+  startTransaction: MaybeFunction;
+  commitTransaction: MaybeFunction;
+  rollbackTransaction: MaybeFunction;
+};
+
+export type GenericResolverSubscription = {
+  subscribe: MaybeFunction;
+  onSubscriptionEvent: string;
+};
+
+export class GenericResolver extends Resolver {
+  implementation: GenericResolverMethods | undefined;
+  subs: GenericResolverSubscription | undefined;
+
+  constructor(name: string, implementation?: GenericResolverMethods) {
+    super(name);
+    this.implementation = implementation;
+  }
+
+  public override async createInstance(inst: Instance): Promise<any> {
+    if (this.implementation?.create) {
+      return await this.implementation.create(this, inst);
+    } else {
+      return await super.createInstance(inst);
+    }
+  }
+
+  public override async upsertInstance(inst: Instance): Promise<any> {
+    if (this.implementation?.upsert) {
+      return await this.implementation.upsert(this, inst);
+    }
+    return await super.upsertInstance(inst);
+  }
+
+  public override async updateInstance(inst: Instance, newAttrs: InstanceAttributes): Promise<any> {
+    if (this.implementation?.update) {
+      return await this.implementation.update(this, inst, newAttrs);
+    }
+    return await super.updateInstance(inst, newAttrs);
+  }
+
+  public override async queryInstances(inst: Instance, queryAll: boolean): Promise<any> {
+    if (this.implementation?.query) {
+      return await this.implementation.query(this, inst, queryAll);
+    }
+    return await super.queryInstances(inst, queryAll);
+  }
+
+  public override async deleteInstance(inst: Instance | Instance[], purge: boolean): Promise<any> {
+    if (this.implementation?.delete) {
+      return await this.implementation.delete(this, inst, purge);
+    }
+    return await super.deleteInstance(inst, purge);
+  }
+
+  public override async startTransaction(): Promise<any> {
+    if (this.implementation?.startTransaction) {
+      return await this.implementation.startTransaction(this);
+    }
+    return await super.startTransaction();
+  }
+
+  public override async commitTransaction(txnId: string): Promise<any> {
+    if (this.implementation?.commitTransaction) {
+      return await this.implementation.commitTransaction(this, txnId);
+    }
+    return await super.commitTransaction(txnId);
+  }
+
+  public override async rollbackTransaction(txnId: string): Promise<any> {
+    if (this.implementation?.rollbackTransaction) {
+      return await this.implementation.rollbackTransaction(this, txnId);
+    }
+    return await super.rollbackTransaction(txnId);
+  }
+
+  override async subscribe() {
+    if (this.subs?.subscribe) {
+      await this.subs.subscribe(this);
+    }
+    await super.subscribe();
   }
 }

package/src/runtime/resolvers/registry.ts

@@ -1,11 +1,12 @@
-import { Resolver } from './interface.js';
+import { Resolver, setSubscriptionEvent } from './interface.js';
 
 type MakeResolver = () => Resolver;
 const resolverDb: Map<string, MakeResolver> = new Map<string, MakeResolver>();
 const resolverPathMappings: Map<string, string> = new Map<string, string>();
 
-export function registerResolver(name: string, r: MakeResolver) {
+export function registerResolver(name: string, r: MakeResolver): string {
   resolverDb.set(name, r);
+  return name;
 }
 
 export function setResolver(fqEntryName: string, resolverName: string) {
@@ -16,6 +17,8 @@ export function setResolver(fqEntryName: string, resolverName: string) {
   }
 }
 
+export const setSubscription = setSubscriptionEvent;
+
 export function getResolverNameForPath(fqEntryName: string): string | undefined {
   return resolverPathMappings.get(fqEntryName);
 }

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

@@ -14,6 +14,7 @@ import {
   InstanceAttributes,
   newInstanceAttributes,
   RbacPermissionFlag,
+  RbacSpecification,
   Relationship,
 } from '../../module.js';
 import pgvector from 'pgvector';
@@ -29,13 +30,15 @@ export class DbContext {
   resourceFqName: string;
   activeEnv: Environment;
   private needAuthCheckFlag: boolean = true;
+  rbacRules: RbacSpecification[] | undefined;
 
   constructor(
     resourceFqName: string,
     authInfo: ResolverAuthInfo,
     activeEnv: Environment,
     txnId?: string,
-    inKernelMode?: boolean
+    inKernelMode?: boolean,
+    rbacRules?: RbacSpecification[]
   ) {
     this.resourceFqName = resourceFqName;
     this.authInfo = authInfo;
@@ -44,6 +47,7 @@ export class DbContext {
     if (inKernelMode != undefined) {
       this.inKernelMode = inKernelMode;
     }
+    this.rbacRules = rbacRules;
   }
   private static GlobalDbContext: DbContext | undefined;
 
@@ -93,6 +97,12 @@ export class DbContext {
     return this;
   }
 
+  switchAuthCheck(flag: boolean): boolean {
+    const old = this.needAuthCheckFlag;
+    this.needAuthCheckFlag = flag;
+    return old;
+  }
+
   isPermitted(): boolean {
     return this.inKernelMode || !this.needAuthCheckFlag;
   }
@@ -379,8 +389,29 @@ export async function insertRows(
   }
   if (hasPerm) {
     await insertRowsHelper(tableName, rows, ctx, doUpsert);
-    if (!ctx.isInKernelMode() && !doUpsert) {
-      await createOwnership(tableName, rows, ctx);
+    if (!doUpsert) {
+      if (!ctx.isInKernelMode()) {
+        await createOwnership(tableName, rows, ctx);
+      }
+      if (ctx.rbacRules) {
+        for (let i = 0; i < ctx.rbacRules.length; ++i) {
+          const rbacRule = ctx.rbacRules[i];
+          const e = rbacRule.expression;
+          if (e) {
+            const [selfRef, userRef] = e.lhs.startsWith('this.') ? [e.lhs, e.rhs] : [e.rhs, e.lhs];
+            if (userRef == 'auth.user') {
+              const attr = selfRef.split('.')[1];
+              for (let j = 0; j < rows.length; ++j) {
+                const r: any = rows[j];
+                const userId = r[attr];
+                if (userId) {
+                  await createLimitedOwnership(tableName, [r], userId, rbacRule.permissions, ctx);
+                }
+              }
+            }
+          }
+        }
+      }
     }
   } else {
     throw new UnauthorisedError({ opr: 'insert', entity: tableName });
@@ -430,13 +461,33 @@ export async function insertBetweenRow(
 
 const PathKey = PathAttributeName as keyof object;
 
+const AllPerms = new Set<RbacPermissionFlag>()
+  .add(RbacPermissionFlag.CREATE)
+  .add(RbacPermissionFlag.READ)
+  .add(RbacPermissionFlag.UPDATE)
+  .add(RbacPermissionFlag.DELETE);
+
 async function createOwnership(tableName: string, rows: object[], ctx: DbContext): Promise<void> {
+  await createLimitedOwnership(tableName, rows, ctx.authInfo.userId, AllPerms, ctx);
+}
+
+async function createLimitedOwnership(
+  tableName: string,
+  rows: object[],
+  userId: string,
+  perms: Set<RbacPermissionFlag>,
+  ctx: DbContext
+): Promise<void> {
   const ownerRows: object[] = [];
   rows.forEach((r: object) => {
     ownerRows.push({
       id: crypto.randomUUID(),
       path: r[PathKey],
-      user_id: ctx.authInfo.userId,
+      user_id: userId,
+      c: perms.has(RbacPermissionFlag.CREATE),
+      r: perms.has(RbacPermissionFlag.READ),
+      d: perms.has(RbacPermissionFlag.DELETE),
+      u: perms.has(RbacPermissionFlag.UPDATE),
     });
   });
   const tname = ownersTable(tableName);

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

@@ -6,6 +6,7 @@ import {
   getAllBetweenRelationships,
   getAllOneToOneRelationshipsForEntity,
   getBetweenInstanceNodeValues,
+  getEntityRbacRules,
   Instance,
   InstanceAttributes,
   isBetweenRelationship,
@@ -72,7 +73,8 @@ export class SqlDbResolver extends Resolver {
       this.authInfo,
       activeEnv,
       this.txnId,
-      activeEnv.isInKernelMode()
+      activeEnv.isInKernelMode(),
+      getEntityRbacRules(resourceFqName)
     );
   }
 
@@ -151,12 +153,11 @@ export class SqlDbResolver extends Resolver {
     let result = SqlDbResolver.EmptyResultSet;
 
     const tableName = asTableName(inst.moduleName, inst.name);
-    const rslt: any = await getMany(
-      tableName,
-      queryAll ? undefined : inst.queryAttributesAsObject(),
-      queryAll ? undefined : inst.queryAttributeValuesAsObject(),
-      this.getDbContext(inst.getFqName())
-    );
+    const fqName = inst.getFqName();
+    const ctx = this.getDbContext(fqName);
+    const qattrs: any = queryAll ? undefined : inst.queryAttributesAsObject();
+    const qvals: any = queryAll ? undefined : inst.queryAttributeValuesAsObject();
+    const rslt: any = await getMany(tableName, qattrs, qvals, ctx);
     if (rslt instanceof Array) {
       result = new Array<Instance>();
       rslt.forEach((r: object) => {

package/src/runtime/state.ts

@@ -38,7 +38,17 @@ export const ConfigSchema = z.object({
       enabled: z.boolean().default(false),
     })
     .optional(),
-  rbacEnabled: z.boolean().optional(),
+  rbac: z
+    .object({
+      enabled: z.boolean().default(false),
+      roles: z.array(z.string()).optional(),
+    })
+    .optional(),
+  auth: z
+    .object({
+      enabled: z.boolean().default(false),
+    })
+    .optional(),
   auditTrail: z
     .object({
       enabled: z.boolean().default(false),

package/src/runtime/util.ts

@@ -88,6 +88,14 @@ export async function invokeModuleFn(
   }
 }
 
+export function getModuleFn(fqFnName: string): Function | undefined {
+  const refs: string[] = splitRefs(fqFnName);
+  const m = importedModules.get(refs[0]);
+  if (m != undefined) {
+    return m[refs[1]];
+  } else return undefined;
+}
+
 export function isNumber(x: any): boolean {
   return typeof x === 'number';
 }
@@ -111,6 +119,14 @@ function asString(s: MaybeString): string {
   else return s;
 }
 
+export function restoreSpecialChars(s: string) {
+  return s.replaceAll('&quote;', '"');
+}
+
+export function escapeSpecialChars(s: string) {
+  return s.replaceAll('"', '&quote;');
+}
+
 export class Path {
   private moduleName: MaybeString;
   private entryName: MaybeString;
@@ -256,6 +272,7 @@ export function arrayEquals(a: Array<any>, b: Array<any>) {
 }
 
 export const DefaultModuleName = 'agentlang';
+export const DefaultModules = new Set();
 
 export function makeCoreModuleName(n: string): string {
   return DefaultModuleName + '_' + n;
@@ -511,3 +528,15 @@ export function walkDownInstancePath(path: string): [string, string, string | un
   }
   return [moduleName, entryName, undefined, parts];
 }
+
+export function areSetsEqual<T>(set1: Set<T>, set2: Set<T>): boolean {
+  if (set1.size !== set2.size) {
+    return false;
+  }
+  for (const item of set1) {
+    if (!set2.has(item)) {
+      return false;
+    }
+  }
+  return true;
+}

package/src/syntaxes/agentlang.monarch.ts

@@ -1,7 +1,7 @@
 // Monarch syntax highlighting for the agentlang language.
 export default {
     keywords: [
-        '@after','@async','@before','@enum','@expr','@meta','@oneof','@rbac','@ref','@with_unique','allow','and','as','await','between','catch','contains','create','delete','else','entity','error','event','extends','false','for','if','import','in','into','like','module','not','not_found','or','purge','read','record','relationship','roles','true','update','upsert','where','workflow'
+        '@actions','@after','@async','@before','@enum','@expr','@meta','@oneof','@rbac','@ref','@upsert','@with_unique','agent','allow','and','as','await','between','catch','contains','create','delete','else','entity','error','event','extends','false','for','if','import','in','into','like','module','not','not_found','onSubscription','or','purge','query','read','record','relationship','resolver','roles','subscribe','true','update','upsert','where','workflow'
     ],
     operators: [
         '*','+',',','-','.','/',':',';','<','<=','<>','=','>','>=','?','@'
@@ -12,7 +12,7 @@ export default {
         initial: [
             { regex: /(([_a-zA-Z][\w_]*)(\/([_a-zA-Z][\w_]*))?)/, action: { cases: { '@keywords': {"token":"keyword"}, '@default': {"token":"string"} }} },
             { regex: /[_a-zA-Z][\w_]*/, action: { cases: { '@keywords': {"token":"keyword"}, '@default': {"token":"string"} }} },
-            { regex: /(["'])((\\{2})*|(.*?[^\\](\\{2})*))\1/, action: {"token":"string"} },
+            { regex: /("(((\\([\s\S]))|((?!(((\\|")|\r)|\n))[\s\S]*?))|(\r?\n))*")/, action: {"token":"string"} },
             { regex: /-?[0-9]+/, action: {"token":"number"} },
             { include: '@whitespace' },
             { regex: /@symbols/, action: { cases: { '@operators': {"token":"operator"}, '@default': {"token":""} }} },

package/src/utils/http.ts

@@ -0,0 +1,5 @@
+import { Buffer } from 'buffer';
+
+export function encodeForBasicAuth(username: string, password: string): string {
+  return Buffer.from(`${username}:${password}`).toString('base64');
+}

package/src/index.ts

@@ -1,29 +0,0 @@
-// Main exports for the agentlang runtime
-export * from './runtime/defs.js';
-export * from './runtime/module.js';
-export * from './runtime/interpreter.js';
-export * from './runtime/loader.js';
-export * from './runtime/state.js';
-export * from './runtime/util.js';
-export * from './runtime/logger.js';
-
-// Export auth interfaces
-export * from './runtime/auth/defs.js';
-export * from './runtime/auth/interface.js';
-
-// Export agent interfaces
-export * from './runtime/agents/common.js';
-export * from './runtime/agents/provider.js';
-export * from './runtime/agents/registry.js';
-
-// Export resolver interfaces
-export * from './runtime/resolvers/interface.js';
-export * from './runtime/resolvers/registry.js';
-
-// Export modules
-export * from './runtime/modules/core.js';
-export * from './runtime/modules/auth.js';
-export * from './runtime/modules/ai.js';
-
-// Export CLI utilities
-export * from './cli/cli-util.js';