agentlang 0.0.2

package/src/runtime/relgraph.ts

@@ -0,0 +1,195 @@
+import {
+  fetchModule,
+  getUserModuleNames,
+  Relationship,
+  RelationshipNode,
+  Module,
+} from './module.js';
+import { DefaultModuleName, Path } from './util.js';
+
+export type RelationshipGraphNode = {
+  entity: Path;
+  edges: RelationshipGraphEdge[];
+};
+
+export type RelationshipGraphEdge = {
+  relationship: Relationship;
+  node: RelationshipGraphNode;
+};
+
+type GraphEdgeEntry = {
+  relationship: string;
+  type: 'contains' | 'between';
+  to: object;
+};
+
+function asEdgeEntry(rge: RelationshipGraphEdge): GraphEdgeEntry {
+  const nm: Map<string, any> = new Map();
+  nm.set(rge.node.entity.asFqName(), rge.node.edges.map(asEdgeEntry));
+  const e: GraphEdgeEntry = {
+    relationship: rge.relationship.getFqName(),
+    type: rge.relationship.isContains() ? 'contains' : 'between',
+    to: Object.fromEntries(nm),
+  };
+  return e;
+}
+
+export class RelationshipGraph {
+  nodes: RelationshipGraphNode[];
+
+  constructor(nodes: Array<RelationshipGraphNode>) {
+    this.nodes = nodes;
+  }
+
+  getRoots(): RelationshipGraphNode[] {
+    return this.nodes;
+  }
+
+  asObject(): object {
+    const result: Map<string, any> = new Map();
+    this.nodes.forEach((node: RelationshipGraphNode) => {
+      result.set(node.entity.asFqName(), node.edges.map(asEdgeEntry));
+    });
+    return Object.fromEntries(result);
+  }
+
+  private walkEdges(
+    node: RelationshipGraphNode,
+    onNode: Function,
+    onContainsRelationship: Function,
+    onBetweenRelationship: Function
+  ) {
+    const n = node.entity.asFqName();
+    onNode(n, node.edges);
+    node.edges.forEach((edge: RelationshipGraphEdge) => {
+      const rf: Function = edge.relationship.isContains()
+        ? onContainsRelationship
+        : onBetweenRelationship;
+      rf(n, edge.node.entity.asFqName(), edge.relationship);
+      this.walkEdges(edge.node, onNode, onContainsRelationship, onBetweenRelationship);
+    });
+  }
+
+  walk(onNode: Function, onContainsRelationship: Function, onBetweenRelationship: Function) {
+    this.nodes.forEach((node: RelationshipGraphNode) => {
+      this.walkEdges(node, onNode, onContainsRelationship, onBetweenRelationship);
+    });
+  }
+}
+
+const NullEdge: Array<RelationshipGraphEdge> = [];
+const EmptyGraph: RelationshipGraph = new RelationshipGraph(new Array<RelationshipGraphNode>());
+
+export function buildGraph(moduleName: string): RelationshipGraph {
+  if (moduleName == DefaultModuleName) return EmptyGraph;
+  const rootEnts: Set<string> = new Set();
+  const inRels: Set<string> = new Set();
+  const nodes: Array<RelationshipGraphNode> = [];
+  let localMod: Module | undefined;
+  getUserModuleNames().forEach((n: string) => {
+    const m: Module = fetchModule(n);
+    if (n == moduleName) localMod = m;
+    const rels: Relationship[] = m.getRelationshipEntries();
+    rels.forEach((re: Relationship) => {
+      const n1: RelationshipNode = re.parentNode();
+      const n2: RelationshipNode = re.childNode();
+      if (n1.path.getModuleName() == moduleName) {
+        const nn: string = n1.path.getEntryName();
+        if (!inRels.has(nn)) rootEnts.add(nn);
+        if (n2.path.getModuleName() == moduleName) {
+          const en: string = n2.path.getEntryName();
+          if (rootEnts.has(en)) {
+            rootEnts.delete(en);
+          }
+          if (re.isContains()) inRels.add(en);
+        }
+        const node: RelationshipGraphNode = forceFindNode(nodes, n1.path);
+        connectEdge(node, re);
+      } else if (n2.path.getModuleName() == moduleName) {
+        const en: string = n2.path.getEntryName();
+        inRels.add(en);
+        const node: RelationshipGraphNode = forceFindNode(nodes, n1.path);
+        connectEdge(node, re);
+      }
+    });
+  });
+  if (localMod == undefined) {
+    throw new Error(`Failed to find module ${moduleName}`);
+  }
+  const remEnts: Set<string> = new Set();
+  const entityNames = localMod.getEntityNames();
+  for (const name of entityNames) {
+    if (!inRels.has(name)) {
+      remEnts.add(name);
+    }
+  }
+  remEnts.forEach((n: string) => {
+    if (!rootEnts.has(n)) {
+      const rn: RelationshipGraphNode = {
+        entity: new Path(moduleName, n),
+        edges: NullEdge,
+      };
+      nodes.push(rn);
+    }
+  });
+  return new RelationshipGraph(nodes);
+}
+
+function forceFindNode(nodes: Array<RelationshipGraphNode>, path: Path) {
+  for (let i = 0; i < nodes.length; ++i) {
+    const n: RelationshipGraphNode = nodes[i];
+    if (n.entity.equals(path)) {
+      return n;
+    } else {
+      const n0: RelationshipGraphNode | undefined = findNodeInEdges(n.edges, path);
+      if (n0) return n0;
+    }
+  }
+  const n: RelationshipGraphNode = {
+    entity: path,
+    edges: NullEdge,
+  };
+  nodes.push(n);
+  return n;
+}
+
+function findNodeInEdges(
+  edges: Array<RelationshipGraphEdge>,
+  path: Path
+): RelationshipGraphNode | undefined {
+  for (let i = 0; i < edges.length; ++i) {
+    const e: RelationshipGraphEdge = edges[i];
+    if (e.node.entity.equals(path)) {
+      return e.node;
+    }
+    const r: RelationshipGraphNode | undefined = findNodeInEdges(e.node.edges, path);
+    if (r) return r;
+  }
+  return undefined;
+}
+
+function connectEdge(node: RelationshipGraphNode, re: Relationship) {
+  const cn: RelationshipNode = re.childNode();
+  const n: RelationshipGraphNode = {
+    entity: cn.path,
+    edges: NullEdge,
+  };
+  const e: RelationshipGraphEdge = {
+    relationship: re,
+    node: n,
+  };
+  if (node.edges == NullEdge) {
+    node.edges = new Array<RelationshipGraphEdge>();
+  }
+  node.edges.push(e);
+}
+
+export function findEdgeForRelationship(
+  relName: string,
+  moduleName: string,
+  edges: RelationshipGraphEdge[]
+): RelationshipGraphEdge | undefined {
+  return edges.find((v: RelationshipGraphEdge) => {
+    return v.relationship.moduleName == moduleName && v.relationship.name == relName;
+  });
+}

package/src/runtime/resolvers/interface.ts

@@ -0,0 +1,160 @@
+import { Instance, InstanceAttributes, Relationship } from '../module.js';
+
+export class ResolverAuthInfo {
+  userId: string;
+  readForUpdate: boolean = false;
+  readForDelete: boolean = false;
+
+  constructor(userId: string, readForUpdate?: boolean, readForDelete?: boolean) {
+    this.userId = userId;
+    if (readForUpdate != undefined) this.readForUpdate = readForUpdate;
+    if (readForDelete != undefined) this.readForDelete = readForDelete;
+  }
+}
+
+export const DefaultAuthInfo = new ResolverAuthInfo(
+  // This user-id is only for testing, per-session user-id needs to be set from
+  // the HTTP layer.
+  '9459a305-5ee6-415d-986d-caaf6d6e2828'
+);
+
+export type JoinInfo = {
+  relationship: Relationship;
+  queryInstance: Instance;
+  subJoins: JoinInfo[] | undefined;
+};
+
+export class Resolver {
+  protected authInfo: ResolverAuthInfo = DefaultAuthInfo;
+  protected userData: any;
+  protected name: string = 'default';
+
+  static Default = new Resolver();
+
+  public setAuthInfo(authInfo: ResolverAuthInfo): Resolver {
+    this.authInfo = authInfo;
+    return this;
+  }
+
+  public setUserData(userData: any): Resolver {
+    this.userData = userData;
+    return this;
+  }
+
+  public getUserData(): any {
+    return this.userData;
+  }
+
+  public getName(): string {
+    return this.name;
+  }
+
+  private notImpl(method: string) {
+    throw new Error(`Resolver method ${method} not implemented`);
+  }
+
+  public onSetPath(moduleName: string, entryName: string): any {
+    this.notImpl(`onSetPath(${moduleName}, ${entryName})`);
+  }
+
+  public async createInstance(inst: Instance): Promise<any> {
+    this.notImpl(`createInstance(${inst})`);
+  }
+
+  public async upsertInstance(inst: Instance): Promise<any> {
+    return this.notImpl(`upsertInstance(${inst})`);
+  }
+
+  /**
+   * @param {Instance} inst - an Instance with query and update attributes
+   * @param {InstanceAttributes} newAttrs - updated attributes to set in instance
+   */
+  public async updateInstance(inst: Instance, newAttrs: InstanceAttributes): Promise<any> {
+    return this.notImpl(`updateInstance(${inst}, ${newAttrs})`);
+  }
+
+  /**
+   * @param {Instance} inst - an Instance with query attributes
+   * @param {boolean} queryAll - if this flag is set, fetch all instances
+   */
+  public async queryInstances(inst: Instance, queryAll: boolean): Promise<any> {
+    return this.notImpl(`queryInstances(${inst}, ${queryAll})`);
+  }
+
+  /**
+   * Return all instances under the given parent-path.
+   * @param {string} parentPath - path of the parent with the relevant relationship name as the last component
+   * @param {Instance} inst - child Instance with query attributes
+   */
+  public async queryChildInstances(parentPath: string, inst: Instance): Promise<any> {
+    return this.notImpl(`queryChildInstances(${parentPath}, ${inst})`);
+  }
+
+  /**
+   * Return all instances connected to connectedInstance via the given between-relationship
+   * @param relationship Between relationship
+   * @param connectedInstance The instance to traveres the relationship from
+   * @param inst Target instance with query attributes
+   */
+  public async queryConnectedInstances(
+    relationship: Relationship,
+    connectedInstance: Instance,
+    inst: Instance
+  ): Promise<any> {
+    return this.notImpl(`queryConnectedInstances(${relationship}, ${connectedInstance}, ${inst})`);
+  }
+
+  public async queryByJoin(
+    inst: Instance,
+    joinsSpec: JoinInfo[],
+    intoSpec: Map<string, string>
+  ): Promise<any> {
+    return this.notImpl(`queryByJoin(${inst}, ${joinsSpec}, ${intoSpec})`);
+  }
+
+  /**
+   * @param {Instance} inst - an Instance with query attributes
+   */
+  public async deleteInstance(inst: Instance | Instance[], purge: boolean): Promise<any> {
+    return this.notImpl(`deleteInstance(${inst}, ${purge})`);
+  }
+
+  /**
+   * Connect instances via a between relationship
+   * @param node1 The main node to connect
+   * @param otherNodeOrNodes Nodes to be connected to node1
+   * @param relEntry Details of the repationship
+   */
+  public async connectInstances(
+    node1: Instance,
+    otherNodeOrNodes: Instance | Instance[],
+    relEntry: Relationship,
+    orUpdate: boolean
+  ): Promise<any> {
+    return this.notImpl(
+      `connectInstances(${node1}, ${otherNodeOrNodes}, ${relEntry}, ${orUpdate})`
+    );
+  }
+
+  public async fullTextSearch(
+    entryName: string,
+    moduleName: string,
+    query: string,
+    options?: Map<string, any>
+  ): Promise<any> {
+    return this.notImpl(`fullTextSearch(${entryName}, ${moduleName}, ${query}, ${options})`);
+  }
+
+  // Return a transactionId
+  public async startTransaction(): Promise<any> {
+    return this.notImpl('startTransaction()');
+  }
+
+  public async commitTransaction(txnId: string): Promise<any> {
+    return this.notImpl(`commitTransaction(${txnId})`);
+  }
+
+  public async rollbackTransaction(txtIn: string): Promise<any> {
+    return this.notImpl(`rollbackTransaction(${txtIn})`);
+  }
+}

package/src/runtime/resolvers/registry.ts

@@ -0,0 +1,30 @@
+import { Resolver } 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) {
+  resolverDb.set(name, r);
+}
+
+export function setResolver(fqEntryName: string, resolverName: string) {
+  if (resolverDb.has(resolverName)) {
+    resolverPathMappings.set(fqEntryName, resolverName);
+  } else {
+    throw new Error(`Resolver not found - ${resolverName}`);
+  }
+}
+
+export function getResolverNameForPath(fqEntryName: string): string | undefined {
+  return resolverPathMappings.get(fqEntryName);
+}
+
+export function getResolver(fqEntryName: string): Resolver {
+  const resName: string | undefined = resolverPathMappings.get(fqEntryName);
+  if (resName != undefined) {
+    const f: MakeResolver | undefined = resolverDb.get(resName);
+    if (f) return f();
+  }
+  throw new Error(`No resolver registered for ${fqEntryName}`);
+}