agentlang 0.0.11 → 0.0.12

package/src/language/generated/grammar.ts

@@ -3244,6 +3244,25 @@ export const AgentlangGrammar = (): Grammar => loadedAgentlangGrammar ?? (loaded
             ],
             "cardinality": "?"
           },
+          {
+            "$type": "Group",
+            "elements": [
+              {
+                "$type": "Keyword",
+                "value": ","
+              },
+              {
+                "$type": "Assignment",
+                "feature": "distinct",
+                "operator": "+=",
+                "terminal": {
+                  "$type": "Keyword",
+                  "value": "@distinct"
+                }
+              }
+            ],
+            "cardinality": "?"
+          },
           {
             "$type": "Keyword",
             "value": "}"
@@ -3341,7 +3360,7 @@ export const AgentlangGrammar = (): Grammar => loadedAgentlangGrammar ?? (loaded
         "elements": [
           {
             "$type": "Keyword",
-            "value": "into"
+            "value": "@into"
           },
           {
             "$type": "Keyword",

package/src/language/syntax.ts

@@ -473,7 +473,7 @@ export class CrudPattern extends BasePattern {
       this.into.forEach((attr: string, alias: string) => {
         ss.push(`${alias} ${attr}`);
       });
-      return `into { ${ss.join(',\n')} }`;
+      return `@into { ${ss.join(',\n')} }`;
     }
     return undefined;
   }

package/src/runtime/interpreter.ts

@@ -408,15 +408,21 @@ export class Environment extends Instance {
     return this.activeTransactions;
   }
 
+  async resetActiveTransactions(commit: boolean): Promise<Environment> {
+    await this.endAllTransactions(commit);
+    this.activeTransactions = new Map<string, string>();
+    return this;
+  }
+
   async getTransactionForResolver(resolver: Resolver): Promise<string> {
     const n: string = resolver.getName();
-    let txnId: string | undefined = this.getActiveTransactions().get(n);
+    let txnId: string | undefined = this.activeTransactions.get(n);
     if (txnId) {
       return txnId;
     } else {
       txnId = await resolver.startTransaction();
       if (txnId) {
-        this.getActiveTransactions().set(n, txnId);
+        this.activeTransactions.set(n, txnId);
         return txnId;
       } else {
         throw new Error(`Failed to start transaction for ${n}`);
@@ -430,7 +436,7 @@ export class Environment extends Instance {
   }
 
   private async endAllTransactions(commit: boolean): Promise<void> {
-    const txns: Map<string, string> = this.getActiveTransactions();
+    const txns: Map<string, string> = this.activeTransactions;
     for (const n of txns.keys()) {
       const txnId: string | undefined = txns.get(n);
       if (txnId) {
@@ -952,6 +958,7 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
   const attrs = inst.attributes;
   const qattrs = inst.queryAttributes;
   const isQueryAll = crud.name.endsWith(QuerySuffix);
+  const distinct: boolean = crud.distinct.length > 0;
   if (attrs.size > 0) {
     await maybeValidateOneOfRefs(inst, env);
   }
@@ -964,7 +971,7 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
     if (qattrs == undefined && !isQueryAll) {
       throw new Error(`Pattern for ${entryName} with 'into' clause must be a query`);
     }
-    await evaluateJoinQuery(crud.into, inst, crud.relationships, env);
+    await evaluateJoinQuery(crud.into, inst, crud.relationships, distinct, env);
     return;
   }
   if (isEntityInstance(inst) || isBetweenRelationship(inst.name, inst.moduleName)) {
@@ -1051,7 +1058,7 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
           isReadForUpdate,
           env.isInDeleteMode()
         );
-        const insts: Instance[] = await res.queryInstances(inst, isQueryAll);
+        const insts: Instance[] = await res.queryInstances(inst, isQueryAll, distinct);
         env.setLastResult(insts);
       }
       if (crud.relationships != undefined) {
@@ -1184,6 +1191,7 @@ async function evaluateJoinQuery(
   intoSpec: SelectIntoSpec,
   inst: Instance,
   relationships: RelationshipPattern[],
+  distinct: boolean,
   env: Environment
 ): Promise<void> {
   const normIntoSpec = new Map<string, string>();
@@ -1196,7 +1204,7 @@ async function evaluateJoinQuery(
     joinsSpec = await walkJoinQueryPattern(relationships[i], joinsSpec, env);
   }
   const resolver = await getResolverForPath(inst.name, moduleName, env);
-  const result: Result = await resolver.queryByJoin(inst, joinsSpec, normIntoSpec);
+  const result: Result = await resolver.queryByJoin(inst, joinsSpec, normIntoSpec, distinct);
   env.setLastResult(result);
 }
 

package/src/runtime/resolvers/interface.ts

@@ -100,8 +100,12 @@ export class Resolver {
    * @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})`);
+  public async queryInstances(
+    inst: Instance,
+    queryAll: boolean,
+    distinct: boolean = false
+  ): Promise<any> {
+    return this.notImpl(`queryInstances(${inst}, ${queryAll}, ${distinct})`);
   }
 
   /**
@@ -130,9 +134,10 @@ export class Resolver {
   public async queryByJoin(
     inst: Instance,
     joinsSpec: JoinInfo[],
-    intoSpec: Map<string, string>
+    intoSpec: Map<string, string>,
+    distinct: boolean = false
   ): Promise<any> {
-    return this.notImpl(`queryByJoin(${inst}, ${joinsSpec}, ${intoSpec})`);
+    return this.notImpl(`queryByJoin(${inst}, ${joinsSpec}, ${intoSpec}, ${distinct})`);
   }
 
   /**

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

@@ -185,7 +185,11 @@ function makeSqliteDataSource(
   });
 }
 
-export const DbType = 'sqlite';
+const DbType = 'sqlite';
+
+function getDbType(config?: DatabaseConfig): string {
+  return process.env.AL_DB_TYPE || config?.type || DbType;
+}
 
 function getDsFunction(
   config: DatabaseConfig | undefined
@@ -194,7 +198,7 @@ function getDsFunction(
   config: DatabaseConfig | undefined,
   synchronize?: boolean | undefined
 ) => DataSource {
-  switch (process.env.AL_DB_TYPE || config?.type || DbType) {
+  switch (getDbType(config)) {
     case 'sqlite':
       return makeSqliteDataSource;
     case 'postgres':
@@ -204,6 +208,10 @@ function getDsFunction(
   }
 }
 
+export function isUsingSqlite(): boolean {
+  return getDbType() == 'sqlite';
+}
+
 export async function initDatabase(config: DatabaseConfig | undefined) {
   if (defaultDataSource == undefined) {
     const mkds = getDsFunction(config);
@@ -602,8 +610,8 @@ function mkBetweenClause(tableName: string | undefined, k: string, queryVals: an
     const v1 = isstr ? `'${ov[0]}'` : ov[0];
     const v2 = isstr ? `'${ov[1]}'` : ov[1];
     const s = tableName
-      ? `${tableName}.${k} BETWEEN ${v1} AND ${v2}`
-      : `${k} BETWEEN ${v1} AND ${v2}`;
+      ? `"${tableName}"."${k}" BETWEEN ${v1} AND ${v2}`
+      : `"${k}" BETWEEN ${v1} AND ${v2}`;
     delete queryVals[k];
     return s;
   } else {
@@ -619,8 +627,8 @@ function objectToWhereClause(queryObj: object, queryVals: any, tableName?: strin
       op == 'between'
         ? mkBetweenClause(tableName, value[0], queryVals)
         : tableName
-          ? `${tableName}.${value[0]} ${op} :${value[0]}`
-          : `${value[0]} ${op} :${value[0]}`;
+          ? `"${tableName}"."${value[0]}" ${op} :${value[0]}`
+          : `"${value[0]}" ${op} :${value[0]}`;
     clauses.push(clause);
   });
   return clauses.join(' AND ');
@@ -637,7 +645,7 @@ function objectToRawWhereClause(queryObj: object, queryVals: any, tableName?: st
     } else {
       const ov: any = queryVals[k];
       const v = isString(ov) ? `'${ov}'` : ov;
-      clause = tableName ? `${tableName}.${k} ${op} ${v}` : `${k} ${op} ${v}`;
+      clause = tableName ? `"${tableName}"."${k}" ${op} ${v}` : `"${k}" ${op} ${v}`;
     }
     clauses.push(clause);
   });
@@ -652,6 +660,7 @@ export async function getMany(
   tableName: string,
   queryObj: object | undefined,
   queryVals: object | undefined,
+  distinct: boolean,
   ctx: DbContext
 ): Promise<any> {
   const alias: string = tableName.toLowerCase();
@@ -697,6 +706,9 @@ export async function getMany(
   if (ownersJoinCond) {
     qb.innerJoin(ot, otAlias, ownersJoinCond.join(' AND '));
   }
+  if (distinct) {
+    qb.distinct(true);
+  }
   qb.where(queryStr, queryVals);
   return await qb.getMany();
 }
@@ -707,6 +719,7 @@ export async function getManyByJoin(
   queryVals: object | undefined,
   joinClauses: JoinClause[],
   intoSpec: Map<string, string>,
+  distinct: boolean,
   ctx: DbContext
 ): Promise<any> {
   const alias: string = tableName.toLowerCase();
@@ -746,7 +759,7 @@ export async function getManyByJoin(
       }
     }
   });
-  const sql = `SELECT ${intoSpecToSql(intoSpec)} FROM ${tableName} ${joinSql.join('\n')} WHERE ${queryStr}`;
+  const sql = `SELECT ${distinct ? 'DISTINCT' : ''} ${intoSpecToSql(intoSpec)} FROM ${tableName} ${joinSql.join('\n')} WHERE ${queryStr}`;
   logger.debug(`Join Query: ${sql}`);
   const qb = getDatasourceForTransaction(ctx.txnId).getRepository(tableName).manager;
   return await qb.query(sql);

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

@@ -30,8 +30,15 @@ export type TableSchema = {
   columns: TableSpec;
 };
 
-export function asTableName(moduleName: string, entityName: string): string {
-  return `${moduleName}_${entityName}`.toLowerCase();
+export function asTableReference(moduleName: string, ref: string): string {
+  if (ref.indexOf('.') > 0) {
+    const parts = ref.split('.')
+    const r = `${moduleName}_${parts[0]}`.toLowerCase()
+    const colref = parts.slice(1).join('.')
+    return `"${r}"."${colref}"`;
+  } else {
+    return `${moduleName}_${ref}`.toLowerCase()
+  }
 }
 
 export function modulesAsDbSchema(): TableSchema[] {
@@ -46,7 +53,7 @@ export function modulesAsDbSchema(): TableSchema[] {
     const allEntries: Record[] = entities.concat(betRels) as Record[];
     allEntries.forEach((ent: Record) => {
       const tspec: TableSchema = {
-        name: asTableName(n, ent.name),
+        name: asTableReference(n, ent.name),
         columns: entitySchemaToTable(ent.schema),
       };
       result.push(tspec);
@@ -85,7 +92,7 @@ function ormSchemaFromRecordSchema(moduleName: string, entry: Record, hasOwnPk?:
   const entityName = entry.name
   const scm: RecordSchema = entry.schema
   const result = new EntitySchemaOptions<any>()
-  result.tableName = asTableName(moduleName, entityName)
+  result.tableName = asTableReference(moduleName, entityName)
   result.name = result.tableName
   const cols = new Map<string, any>()
   const indices = new Array<any>()

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

@@ -15,7 +15,7 @@ import {
 } from '../../module.js';
 import { escapeFqName, makeFqName, splitFqName } from '../../util.js';
 import { JoinInfo, Resolver } from '../interface.js';
-import { asTableName } from './dbutil.js';
+import { asTableReference } from './dbutil.js';
 import {
   getMany,
   insertRow,
@@ -103,7 +103,7 @@ export class SqlDbResolver extends Resolver {
         else p = `${n.replace('/', '$')}/${idAttrVal}`;
         attrs.set(PathAttributeName, p);
       }
-      const n: string = asTableName(inst.moduleName, inst.name);
+      const n: string = asTableReference(inst.moduleName, inst.name);
       const rowObj: object = inst.attributesWithStringifiedObjects();
       const ctx = this.getDbContext(inst.getFqName());
       await insertRow(n, rowObj, ctx, orUpdate);
@@ -140,7 +140,7 @@ export class SqlDbResolver extends Resolver {
     );
     const updateObj: object = Object.fromEntries(newAttrs);
     await updateRow(
-      asTableName(inst.moduleName, inst.name),
+      asTableReference(inst.moduleName, inst.name),
       queryObj,
       queryVals,
       updateObj,
@@ -153,16 +153,17 @@ export class SqlDbResolver extends Resolver {
 
   public override async queryInstances(
     inst: Instance,
-    queryAll: boolean = false
+    queryAll: boolean = false,
+    distinct: boolean = false
   ): Promise<Instance[]> {
     let result = SqlDbResolver.EmptyResultSet;
 
-    const tableName = asTableName(inst.moduleName, inst.name);
+    const tableName = asTableReference(inst.moduleName, inst.name);
     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);
+    const rslt: any = await getMany(tableName, qattrs, qvals, distinct, ctx);
     if (rslt instanceof Array) {
       result = new Array<Instance>();
       rslt.forEach((r: object) => {
@@ -217,11 +218,11 @@ export class SqlDbResolver extends Resolver {
       return await this.queryInstances(inst, false);
     } else {
       await getAllConnected(
-        asTableName(inst.moduleName, inst.name),
+        asTableReference(inst.moduleName, inst.name),
         inst.queryAttributesAsObject(),
         inst.queryAttributeValuesAsObject(),
         {
-          connectionTable: asTableName(inst.moduleName, relationship.name),
+          connectionTable: asTableReference(inst.moduleName, relationship.name),
           fromColumn: relationship.node1.alias,
           fromValue: `'${connectedInstance.lookup(PathAttributeName)}'`,
           toColumn: relationship.node2.alias,
@@ -249,15 +250,16 @@ export class SqlDbResolver extends Resolver {
   public override async queryByJoin(
     inst: Instance,
     joinsSpec: JoinInfo[],
-    intoSpec: Map<string, string>
+    intoSpec: Map<string, string>,
+    distinct: boolean = false
   ): Promise<any> {
-    const tableName = asTableName(inst.moduleName, inst.name);
+    const tableName = asTableReference(inst.moduleName, inst.name);
     const joinClauses: JoinClause[] = [];
     this.processJoinInfo(tableName, inst, joinsSpec, joinClauses);
     intoSpec.forEach((v: string, k: string) => {
       const p = splitFqName(v);
       const mn = p.hasModule() ? p.getModuleName() : inst.moduleName;
-      intoSpec.set(k, asTableName(mn, p.getEntryName()));
+      intoSpec.set(k, asTableReference(mn, p.getEntryName()));
     });
     const rslt: any = await getManyByJoin(
       tableName,
@@ -265,6 +267,7 @@ export class SqlDbResolver extends Resolver {
       inst.queryAttributeValuesAsObject(),
       joinClauses,
       intoSpec,
+      distinct,
       this.getDbContext(inst.getFqName())
     );
     return rslt;
@@ -278,7 +281,7 @@ export class SqlDbResolver extends Resolver {
   ) {
     joinsSpec.forEach((ji: JoinInfo) => {
       const rel: Relationship = ji.relationship;
-      const joinTableName = asTableName(ji.queryInstance.moduleName, ji.queryInstance.name);
+      const joinTableName = asTableReference(ji.queryInstance.moduleName, ji.queryInstance.name);
       let joinOn: JoinOn | JoinOn[] | undefined;
       if (rel.isContains()) {
         const walkDown = rel.isParent(joinInst);
@@ -295,7 +298,7 @@ export class SqlDbResolver extends Resolver {
             pathRef
           );
         } else {
-          const relTableName = asTableName(rel.moduleName, rel.name);
+          const relTableName = asTableReference(rel.moduleName, rel.name);
           const jPathRef = `"${joinTableName}"."${PathAttributeName}"`;
           const fqn = ji.queryInstance.getFqName();
           const n1 = rel.getAliasForName(fqn);
@@ -333,7 +336,7 @@ export class SqlDbResolver extends Resolver {
     const queryVals: object = Object.fromEntries(
       newInstanceAttributes().set(PathAttributeName, target.attributes.get(PathAttributeName))
     );
-    const tableName = asTableName(target.moduleName, target.name);
+    const tableName = asTableReference(target.moduleName, target.name);
     const ctx = this.getDbContext(target.getFqName());
     if (purge) {
       await hardDeleteRow(tableName, [[PathAttributeName, target.lookup(PathAttributeName)]], ctx);
@@ -374,7 +377,7 @@ export class SqlDbResolver extends Resolver {
     relEntry: Relationship,
     orUpdate: boolean
   ): Promise<void> {
-    const n: string = asTableName(relEntry.moduleName, relEntry.name);
+    const n: string = asTableReference(relEntry.moduleName, relEntry.name);
     const [firstNode, secondNode] = relEntry.isFirstNode(node1) ? [node1, node2] : [node2, node1];
     const a1: string = relEntry.node1.alias;
     const a2: string = relEntry.node2.alias;
@@ -423,7 +426,7 @@ export class SqlDbResolver extends Resolver {
     if (options && options.has('limit')) {
       limit = options.get('limit') as number;
     }
-    return await vectorStoreSearch(asTableName(moduleName, entryName), queryVec, limit, ctx);
+    return await vectorStoreSearch(asTableReference(moduleName, entryName), queryVec, limit, ctx);
   }
 
   public override async startTransaction(): Promise<string> {

package/src/syntaxes/agentlang.monarch.ts

@@ -1,7 +1,7 @@
 // Monarch syntax highlighting for the agentlang language.
 export default {
     keywords: [
-        '@actions','@after','@as','@async','@before','@catch','@enum','@expr','@from','@meta','@oneof','@rbac','@ref','@upsert','@with_unique','agent','allow','and','await','between','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','return','roles','subscribe','true','update','upsert','where','workflow'
+        '@actions','@after','@as','@async','@before','@catch','@distinct','@enum','@expr','@from','@into','@meta','@oneof','@rbac','@ref','@upsert','@with_unique','agent','allow','and','await','between','contains','create','delete','else','entity','error','event','extends','false','for','if','import','in','like','module','not','not_found','onSubscription','or','purge','query','read','record','relationship','resolver','return','roles','subscribe','true','update','upsert','where','workflow'
     ],
     operators: [
         '*','+',',','-','.','/',':',';','<','<=','<>','=','>','>=','?','@'