agentlang 0.5.0 → 0.5.1

package/src/runtime/defs.ts

@@ -300,3 +300,14 @@ export class ExecGraphWalker {
     return this;
   }
 }
+
+export type FkSpec = {
+  moduleName: string;
+  entityName: string;
+  columnName: string;
+  targetModuleName: string;
+  targetEntityName: string;
+  targetColumnName: string;
+  onDelete: 'CASCADE' | 'SET NULL' | 'SET DEFAULT' | undefined;
+  onUpdate: 'CASCADE' | 'SET NULL' | 'SET DEFAULT' | undefined;
+};

package/src/runtime/interpreter.ts

@@ -14,6 +14,7 @@ import {
   isNegExpr,
   isNotExpr,
   isReturn,
+  JoinSpec,
   Literal,
   MapKey,
   MapLiteral,
@@ -1298,7 +1299,11 @@ 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, distinct, env);
+    if (crud.join) {
+      await evaluateJoinQuery(crud.join, crud.into, inst, distinct, env);
+    } else {
+      await evaluateJoinQueryWithRelationships(crud.into, inst, crud.relationships, distinct, env);
+    }
     return;
   }
   if (isEntityInstance(inst) || isBetweenRelationship(inst.name, inst.moduleName)) {
@@ -1576,6 +1581,25 @@ async function computeExprAttributes(
 }
 
 async function evaluateJoinQuery(
+  joinSpec: JoinSpec,
+  intoSpec: SelectIntoSpec,
+  inst: Instance,
+  distinct: boolean,
+  env: Environment
+): Promise<void> {
+  const normIntoSpec = new Map<string, string>();
+  intoSpec.entries.forEach((entry: SelectIntoEntry) => {
+    normIntoSpec.set(entry.alias, entry.attribute);
+  });
+  const resolver = await getResolverForPath(inst.name, inst.moduleName, env);
+  const result: Result = await resolver.queryByJoin(inst, [], normIntoSpec, distinct, joinSpec);
+
+  const transformedResult = transformDateFieldsInJoinResult(result);
+
+  env.setLastResult(transformedResult);
+}
+
+async function evaluateJoinQueryWithRelationships(
   intoSpec: SelectIntoSpec,
   inst: Instance,
   relationships: RelationshipPattern[],

package/src/runtime/module.ts

@@ -43,10 +43,12 @@ import {
   escapeFqName,
   encryptPassword,
   splitFqName,
+  splitRefs,
+  forceAsFqName,
 } from './util.js';
 import { parseStatement } from '../language/parser.js';
 import { ActiveSessionInfo, AdminSession } from './auth/defs.js';
-import { FetchModuleFn, PathAttributeName } from './defs.js';
+import { FetchModuleFn, FkSpec, PathAttributeName } from './defs.js';
 import { logger } from './logger.js';
 import { CasePattern, FlowStepPattern } from '../language/syntax.js';
 import {
@@ -323,7 +325,7 @@ export class Record extends ModuleEntry {
             props = new Map();
           }
           props.set('ref', escapeFqName(fp));
-          t = 'Path';
+          t = a.refSpec.type === undefined ? 'Any' : a.refSpec.type;
         }
         const enumValues: string[] | undefined = a.enumSpec?.values;
         const oneOfRef: string | undefined = a.oneOfSpec?.ref;
@@ -533,6 +535,37 @@ export class Record extends ModuleEntry {
     return undefined;
   }
 
+  getFkAttributeSpecs(): FkSpec[] {
+    const result = new Array<FkSpec>();
+    this.schema.forEach((attrSpec: AttributeSpec, columnName: string) => {
+      const refSpec = getRefSpec(attrSpec);
+      if (refSpec) {
+        const targetNames = forceAsFqName(refSpec, this.moduleName);
+        const parts = splitFqName(targetNames);
+        const targetModuleName = parts[0];
+        const refs = splitRefs(parts[1]);
+        const targetEntityName = refs[0];
+        let targetColumnName = '';
+        if (refs.length <= 1) {
+          targetColumnName = PathAttributeName;
+        } else {
+          targetColumnName = refs[1];
+        }
+        result.push({
+          moduleName: this.moduleName,
+          entityName: this.name,
+          columnName,
+          targetModuleName,
+          targetEntityName,
+          targetColumnName,
+          onDelete: 'CASCADE',
+          onUpdate: 'CASCADE',
+        });
+      }
+    });
+    return result;
+  }
+
   override toString(): string {
     return this.toString_();
   }

package/src/runtime/modules/auth.ts

@@ -32,7 +32,7 @@ export default `module ${CoreAuthModuleName}
 import "./modules/auth.js" @as Auth
 
 entity User {
-    id UUID @id @default(uuid()),
+    id UUID @id @default(uuid()) @unique,
     email Email @unique @indexed,
     firstName String,
     lastName String,

package/src/runtime/resolvers/interface.ts

@@ -1,3 +1,4 @@
+import { JoinSpec } from '../../language/generated/ast.js';
 import {
   callPostEventOnSubscription,
   Environment,
@@ -127,11 +128,14 @@ export class Resolver {
 
   public async queryByJoin(
     inst: Instance,
-    joinsSpec: JoinInfo[],
+    joinInfo: JoinInfo[],
     intoSpec: Map<string, string>,
-    distinct: boolean = false
+    distinct: boolean = false,
+    rawJoinSpec?: JoinSpec
   ): Promise<any> {
-    return this.notImpl(`queryByJoin(${inst}, ${joinsSpec}, ${intoSpec}, ${distinct})`);
+    return this.notImpl(
+      `queryByJoin(${inst}, ${joinInfo}, ${intoSpec}, ${distinct} ${rawJoinSpec})`
+    );
   }
 
   /**

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

@@ -1,6 +1,14 @@
-import { DataSource, EntityManager, EntitySchema, QueryRunner, SelectQueryBuilder } from 'typeorm';
+import {
+  DataSource,
+  EntityManager,
+  EntitySchema,
+  QueryRunner,
+  SelectQueryBuilder,
+  TableForeignKey,
+} from 'typeorm';
 import { logger } from '../../logger.js';
 import {
+  asTableReference,
   DefaultVectorDimension,
   modulesAsOrmSchema,
   OwnersSuffix,
@@ -138,6 +146,7 @@ export type JoinClause = {
   tableName: string;
   queryObject?: object;
   queryValues?: object;
+  joinType?: string; // 'join' | 'inner join' | 'left join' | 'right join' | 'full join'
   joinOn: JoinOn | JoinOn[];
 };
 
@@ -168,6 +177,10 @@ function makePostgresDataSource(
     database: process.env.POSTGRES_DB || config?.dbname || 'postgres',
     synchronize: synchronize,
     entities: entities,
+    invalidWhereValuesBehavior: {
+      null: 'sql-null',
+      undefined: 'ignore',
+    },
   });
 }
 
@@ -190,6 +203,10 @@ function makeSqliteDataSource(
     database: config?.dbname || mkDbName(),
     synchronize: synchronize,
     entities: entities,
+    invalidWhereValuesBehavior: {
+      null: 'sql-null',
+      undefined: 'ignore',
+    },
   });
 }
 
@@ -288,6 +305,20 @@ export async function initDatabase(config: DatabaseConfig | undefined) {
       const ormScm = modulesAsOrmSchema();
       defaultDataSource = mkds(ormScm.entities, config) as DataSource;
       await defaultDataSource.initialize();
+      if (ormScm.fkSpecs.length > 0) {
+        const qr = defaultDataSource.createQueryRunner();
+        for (let i = 0; i < ormScm.fkSpecs.length; ++i) {
+          const fk = ormScm.fkSpecs[i];
+          const fkobj = new TableForeignKey({
+            columnNames: [fk.columnName],
+            referencedColumnNames: [fk.targetColumnName],
+            referencedTableName: asTableReference(fk.targetModuleName, fk.targetEntityName),
+            onDelete: fk.onDelete,
+            onUpdate: fk.onUpdate,
+          });
+          await qr.createForeignKey(asTableReference(fk.moduleName, fk.entityName), fkobj);
+        }
+      }
       const vectEnts = ormScm.vectorEntities.map((es: EntitySchema) => {
         return es.options.name;
       });
@@ -716,13 +747,25 @@ function mkBetweenClause(tableName: string | undefined, k: string, queryVals: an
 function objectToWhereClause(queryObj: object, queryVals: any, tableName?: string): string {
   const clauses: Array<string> = new Array<string>();
   Object.entries(queryObj).forEach((value: [string, any]) => {
-    const op: string = value[1] as string;
+    let op: string = value[1] as string;
+    const k = value[0];
+    const isnullcheck = queryVals[k] === null;
+    if (isnullcheck) {
+      if (op === '=') {
+        op = 'IS';
+      } else if (op === '<>' || op === '!=') {
+        op = 'IS NOT';
+      } else {
+        throw new Error(`Operator ${op} cannot be appplied to SQL NULL`);
+      }
+    }
+    const v = isnullcheck ? 'NULL' : `:${k}`;
     const clause =
       op == 'between'
-        ? mkBetweenClause(tableName, value[0], queryVals)
+        ? mkBetweenClause(tableName, k, queryVals)
         : tableName
-          ? `"${tableName}"."${value[0]}" ${op} :${value[0]}`
-          : `"${value[0]}" ${op} :${value[0]}`;
+          ? `"${tableName}"."${k}" ${op} ${v}`
+          : `"${k}" ${op} ${v}`;
     clauses.push(clause);
   });
   return clauses.join(' AND ');
@@ -731,8 +774,17 @@ function objectToWhereClause(queryObj: object, queryVals: any, tableName?: strin
 function objectToRawWhereClause(queryObj: object, queryVals: any, tableName?: string): string {
   const clauses: Array<string> = new Array<string>();
   Object.entries(queryObj).forEach((value: [string, any]) => {
-    const op: string = value[1] as string;
+    let op: string = value[1] as string;
     const k: string = value[0];
+    if (queryVals[k] === null) {
+      if (op === '=') {
+        op = 'IS';
+      } else if (op === '<>' || op === '!=') {
+        op = 'IS NOT';
+      } else {
+        throw new Error(`Operator ${op} cannot be appplied to SQL NULL`);
+      }
+    }
     let clause = '';
     if (op == 'between') {
       clause = mkBetweenClause(tableName, k, queryVals);
@@ -843,8 +895,9 @@ export async function getManyByJoin(
   }
   const joinSql = new Array<string>();
   joinClauses.forEach((jc: JoinClause) => {
+    const joinType = jc.joinType ? jc.joinType : 'inner join';
     joinSql.push(
-      `inner join ${jc.tableName} as ${jc.tableName} on ${joinOnAsSql(jc.joinOn)} AND ${jc.tableName}.${DeletedFlagAttributeName} = false`
+      `${joinType} ${jc.tableName} as ${jc.tableName} on ${joinOnAsSql(jc.joinOn)} AND ${jc.tableName}.${DeletedFlagAttributeName} = false`
     );
     if (jc.queryObject) {
       const q = objectToRawWhereClause(jc.queryObject, jc.queryValues, jc.tableName);

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

@@ -1,4 +1,12 @@
-import { ColumnType, EntitySchema, EntitySchemaColumnOptions, EntitySchemaOptions, TableColumnOptions, TableForeignKey, TableIndexOptions } from 'typeorm';
+import {
+  ColumnType,
+  EntitySchema,
+  EntitySchemaColumnOptions,
+  EntitySchemaOptions,
+  TableColumnOptions,
+  TableForeignKey,
+  TableIndexOptions,
+} from 'typeorm';
 import {
   AttributeSpec,
   fetchModule,
@@ -21,9 +29,9 @@ import {
 } from '../../module.js';
 import { buildGraph } from '../../relgraph.js';
 import { makeFqName } from '../../util.js';
-import { DeletedFlagAttributeName, ParentAttributeName, PathAttributeName } from '../../defs.js';
+import { DeletedFlagAttributeName, FkSpec, ParentAttributeName, PathAttributeName } from '../../defs.js';
 
-export const DefaultVectorDimension = 1536
+export const DefaultVectorDimension = 1536;
 
 export type TableSchema = {
   name: string;
@@ -31,14 +39,14 @@ export type TableSchema = {
 };
 
 export function asTableReference(moduleName: string, ref: string): string {
-  const modName = moduleName.replace('.', '_')
+  const modName = moduleName.replace('.', '_');
   if (ref.indexOf('.') > 0) {
-    const parts = ref.split('.')
-    const r = `${modName}_${parts[0]}`.toLowerCase()
-    const colref = parts.slice(1).join('.')
+    const parts = ref.split('.');
+    const r = `${modName}_${parts[0]}`.toLowerCase();
+    const colref = parts.slice(1).join('.');
     return `"${r}"."${colref}"`;
   } else {
-    return `${modName}_${ref}`.toLowerCase()
+    return `${modName}_${ref}`.toLowerCase();
   }
 }
 
@@ -64,123 +72,148 @@ export function modulesAsDbSchema(): TableSchema[] {
 }
 
 export type OrmSchema = {
-  entities: EntitySchema[],
-  vectorEntities: EntitySchema[]
-}
+  entities: EntitySchema[];
+  vectorEntities: EntitySchema[];
+  fkSpecs: FkSpec[];
+};
 
 export function modulesAsOrmSchema(): OrmSchema {
   const ents: EntitySchema[] = [];
-  const vects: EntitySchema[] = []
+  const vects: EntitySchema[] = [];
+  const fkSpecs: FkSpec[] = [];
   getModuleNames().forEach((n: string) => {
     buildGraph(n);
     const mod: Module = fetchModule(n);
-    const entities: Record[] = mod.getEntityEntries()
+    const entities: Record[] = mod.getEntityEntries();
     const rels: Record[] = mod.getBetweenRelationshipEntriesThatNeedStore();
     entities.concat(rels).forEach((entry: Record) => {
-      ents.push(new EntitySchema<any>(ormSchemaFromRecordSchema(n, entry)))
-      const ownerEntry = createOwnersEntity(entry)
-      ents.push(new EntitySchema<any>(ormSchemaFromRecordSchema(n, ownerEntry, true)))
+      ents.push(new EntitySchema<any>(ormSchemaFromRecordSchema(n, entry)));
+      const ownerEntry = createOwnersEntity(entry);
+      ents.push(new EntitySchema<any>(ormSchemaFromRecordSchema(n, ownerEntry, true)));
       if (entry.getFullTextSearchAttributes()) {
-        const vectorEntry = createVectorEntity(entry)
-        vects.push(new EntitySchema<any>(ormSchemaFromRecordSchema(n, vectorEntry, true)))
+        const vectorEntry = createVectorEntity(entry);
+        vects.push(new EntitySchema<any>(ormSchemaFromRecordSchema(n, vectorEntry, true)));
+      }
+    });
+    entities.forEach((r: Record) => {
+      const fks = r.getFkAttributeSpecs()
+      if (fks.length > 0) {
+        fkSpecs.push(...fks)
       }
     })
-  })
-  return { entities: ents, vectorEntities: vects }
+  });
+  return { entities: ents, vectorEntities: vects, fkSpecs };
 }
 
-function ormSchemaFromRecordSchema(moduleName: string, entry: Record, hasOwnPk?: boolean): EntitySchemaOptions<any> {
-  const entityName = entry.name
-  const scm: RecordSchema = entry.schema
-  const result = new EntitySchemaOptions<any>()
-  result.tableName = asTableReference(moduleName, entityName)
-  result.name = result.tableName
-  const cols = new Map<string, any>()
-  const indices = new Array<any>()
-  const chkforpk: boolean = hasOwnPk == undefined ? false : true
-  let needPath = true
+function ormSchemaFromRecordSchema(
+  moduleName: string,
+  entry: Record,
+  hasOwnPk?: boolean
+): EntitySchemaOptions<any> {
+  const entityName = entry.name;
+  const scm: RecordSchema = entry.schema;
+  const result = new EntitySchemaOptions<any>();
+  result.tableName = asTableReference(moduleName, entityName);
+  result.name = result.tableName;
+  const cols = new Map<string, any>();
+  const indices = new Array<any>();
+  const chkforpk: boolean = hasOwnPk == undefined ? false : true;
+  let needPath = true;
   scm.forEach((attrSpec: AttributeSpec, attrName: string) => {
     let d: any = getAttributeDefaultValue(attrSpec);
     const autoUuid: boolean = d && d == 'uuid()' ? true : false;
     const autoIncr: boolean = !autoUuid && d && d == 'autoincrement()' ? true : false;
     if (autoUuid || autoIncr) d = undefined;
-    let genStrat: 'uuid' | 'increment' | undefined = undefined
+    let genStrat: 'uuid' | 'increment' | undefined = undefined;
     if (autoIncr) genStrat = 'increment';
     else if (autoUuid) genStrat = 'uuid';
-    const isuq: boolean = isUniqueAttribute(attrSpec)
-    const ispk: boolean = chkforpk && isIdAttribute(attrSpec)
+    const isuq: boolean = isUniqueAttribute(attrSpec);
+    const ispk: boolean = chkforpk && isIdAttribute(attrSpec);
     const colDef: EntitySchemaColumnOptions = {
       type: asSqlType(attrSpec.type),
       generated: genStrat,
       default: d,
       unique: isuq,
       primary: ispk,
-      nullable: isOptionalAttribute(attrSpec)
+      nullable: isOptionalAttribute(attrSpec),
     };
     if (ispk) {
-      needPath = false
+      needPath = false;
     }
     if (isIndexedAttribute(attrSpec)) {
-      indices.push(Object.fromEntries(new Map()
-        .set('name', `${result.tableName}_${attrName}_index`)
-        .set('columns', [attrName])
-        .set('unique', isuq)))
+      indices.push(
+        Object.fromEntries(
+          new Map()
+            .set('name', `${result.tableName}_${attrName}_index`)
+            .set('columns', [attrName])
+            .set('unique', isuq)
+        )
+      );
     }
-    cols.set(attrName, colDef)
+    cols.set(attrName, colDef);
   });
   if (needPath) {
-    cols.set(PathAttributeName, { type: "varchar", primary: true })
-    cols.set(ParentAttributeName, { type: "varchar", default: '', indexed: true })
+    cols.set(PathAttributeName, { type: 'varchar', primary: true });
+    cols.set(ParentAttributeName, { type: 'varchar', default: '', indexed: true });
   }
-  cols.set(DeletedFlagAttributeName, { type: "boolean", default: false })
-  const allBetRels = getAllBetweenRelationships()
-  const relsSpec = new Map()
-  const fqName = makeFqName(moduleName, entityName)
-  getAllOneToOneRelationshipsForEntity(moduleName, entityName, allBetRels)
-    .forEach((re: Relationship) => {
-      const colName = re.getInverseAliasForName(fqName)
+  cols.set(DeletedFlagAttributeName, { type: 'boolean', default: false });
+  const allBetRels = getAllBetweenRelationships();
+  const relsSpec = new Map();
+  const fqName = makeFqName(moduleName, entityName);
+  getAllOneToOneRelationshipsForEntity(moduleName, entityName, allBetRels).forEach(
+    (re: Relationship) => {
+      const colName = re.getInverseAliasForName(fqName);
       if (cols.has(colName)) {
-        throw new Error(`Cannot establish relationship ${re.name}, ${entityName}.${colName} already exists`)
+        throw new Error(
+          `Cannot establish relationship ${re.name}, ${entityName}.${colName} already exists`
+        );
       }
-      cols.set(colName, { type: "varchar", unique: true })
-    })
+      cols.set(colName, { type: 'varchar', unique: true });
+    }
+  );
   if (relsSpec.size > 0) {
-    result.relations = Object.fromEntries(relsSpec)
+    result.relations = Object.fromEntries(relsSpec);
   }
-  result.columns = Object.fromEntries(cols)
-  const compUqs = entry.getCompositeUniqueAttributes()
+  result.columns = Object.fromEntries(cols);
+  const compUqs = entry.getCompositeUniqueAttributes();
   if (compUqs) {
-    indices.push(Object.fromEntries(new Map()
-      .set('name', `${result.tableName}__comp__index`)
-      .set('columns', compUqs)
-      .set('unique', true)))
+    indices.push(
+      Object.fromEntries(
+        new Map()
+          .set('name', `${result.tableName}__comp__index`)
+          .set('columns', compUqs)
+          .set('unique', true)
+      )
+    );
   }
   if (indices.length > 0) {
-    result.indices = indices
+    result.indices = indices;
   }
-  return result
+  return result;
 }
 
-export const OwnersSuffix = '_owners'
-export const VectorSuffix = '_vector'
+export const OwnersSuffix = '_owners';
+export const VectorSuffix = '_vector';
 
 function createOwnersEntity(entry: Record): Record {
-  const ownersEntry = new Record(`${entry.name}${OwnersSuffix}`, entry.moduleName)
-  const permProps = new Map().set('default', true)
-  return ownersEntry.addAttribute('id', { type: 'UUID', properties: new Map().set('id', true) })
+  const ownersEntry = new Record(`${entry.name}${OwnersSuffix}`, entry.moduleName);
+  const permProps = new Map().set('default', true);
+  return ownersEntry
+    .addAttribute('id', { type: 'UUID', properties: new Map().set('id', true) })
     .addAttribute('user_id', { type: 'String' })
     .addAttribute('type', { type: 'String', properties: new Map().set('default', 'o') })
     .addAttribute('c', { type: 'Boolean', properties: permProps })
     .addAttribute('r', { type: 'Boolean', properties: permProps })
     .addAttribute('u', { type: 'Boolean', properties: permProps })
     .addAttribute('d', { type: 'Boolean', properties: permProps })
-    .addAttribute('path', { type: 'String', properties: new Map().set('indexed', true) })
+    .addAttribute('path', { type: 'String', properties: new Map().set('indexed', true) });
 }
 
 function createVectorEntity(entry: Record): Record {
-  const ownersEntry = new Record(`${entry.name}${VectorSuffix}`, entry.moduleName)
-  return ownersEntry.addAttribute('id', { type: 'String', properties: new Map().set('id', true) })
-    .addAttribute('embedding', { type: `vector(${DefaultVectorDimension})` })
+  const ownersEntry = new Record(`${entry.name}${VectorSuffix}`, entry.moduleName);
+  return ownersEntry
+    .addAttribute('id', { type: 'String', properties: new Map().set('id', true) })
+    .addAttribute('embedding', { type: `vector(${DefaultVectorDimension})` });
 }
 
 export type TableSpec = {
@@ -250,12 +283,19 @@ function entitySchemaToTable(scm: RecordSchema): TableSpec {
 }
 
 export function asSqlType(type: string): ColumnType {
-  const t = type.toLowerCase()
-  if (t == 'string' || t == 'datetime' || t == 'email' || t == 'url'
-    || t == 'map' || t == 'any' || t == 'path')
+  const t = type.toLowerCase();
+  if (
+    t == 'string' ||
+    t == 'datetime' ||
+    t == 'email' ||
+    t == 'url' ||
+    t == 'map' ||
+    t == 'any' ||
+    t == 'path'
+  )
     return 'varchar';
   else if (t == 'int') return 'integer';
-  else if (t == 'number') return 'double precision'
+  else if (t == 'number') return 'double precision';
   else if (!isBuiltInType(type)) return 'varchar';
   else return t as ColumnType;
 }

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

@@ -13,7 +13,15 @@ import {
   newInstanceAttributes,
   Relationship,
 } from '../../module.js';
-import { escapeFqName, makeFqName, nameToPath } from '../../util.js';
+import {
+  escapeFqName,
+  escapeQueryName,
+  isFqName,
+  makeFqName,
+  nameToPath,
+  splitFqName,
+  splitRefs,
+} from '../../util.js';
 import { JoinInfo, Resolver } from '../interface.js';
 import { asTableReference } from './dbutil.js';
 import {
@@ -41,6 +49,7 @@ import { OpenAIEmbeddings } from '@langchain/openai';
 import { Embeddings } from '@langchain/core/embeddings';
 import { DeletedFlagAttributeName, ParentAttributeName, PathAttributeName } from '../../defs.js';
 import { logger } from '../../logger.js';
+import { JoinSpec } from '../../../language/generated/ast.js';
 
 function maybeFindIdAttributeName(inst: Instance): string | undefined {
   const attrEntry: AttributeEntry | undefined = findIdAttribute(inst);
@@ -251,13 +260,18 @@ export class SqlDbResolver extends Resolver {
 
   public override async queryByJoin(
     inst: Instance,
-    joinsSpec: JoinInfo[],
+    joinInfo: JoinInfo[],
     intoSpec: Map<string, string>,
-    distinct: boolean = false
+    distinct: boolean = false,
+    rawJoinSpec?: JoinSpec
   ): Promise<any> {
     const tableName = asTableReference(inst.moduleName, inst.name);
     const joinClauses: JoinClause[] = [];
-    this.processJoinInfo(tableName, inst, joinsSpec, joinClauses);
+    if (rawJoinSpec) {
+      this.processRawJoinSpec(tableName, inst, rawJoinSpec, joinClauses);
+    } else {
+      this.processJoinInfo(tableName, inst, joinInfo, joinClauses);
+    }
     intoSpec.forEach((v: string, k: string) => {
       const p = nameToPath(v);
       const mn = p.hasModule() ? p.getModuleName() : inst.moduleName;
@@ -275,13 +289,46 @@ export class SqlDbResolver extends Resolver {
     return rslt;
   }
 
+  private processRawJoinSpec(
+    tableName: string,
+    inst: Instance,
+    rawJoinSpec: JoinSpec,
+    joinClauses: JoinClause[]
+  ) {
+    const n = rawJoinSpec.name;
+    let joinTableName = '';
+    if (isFqName(n)) {
+      const parts = splitFqName(n);
+      joinTableName = asTableReference(parts[0], parts[1]);
+    } else {
+      joinTableName = asTableReference(inst.moduleName, n);
+    }
+    const refParts = splitRefs(rawJoinSpec.rhs);
+    if (refParts.length != 2) {
+      throw new Error(`Invalid join referene - ${rawJoinSpec.rhs}`);
+    }
+    if (refParts[0] !== inst.name) {
+      throw new Error(`Invalid table name in join reference - ${rawJoinSpec.rhs}`);
+    }
+    const joinOn = makeJoinOn(
+      `"${joinTableName}"."${escapeQueryName(rawJoinSpec.lhs)}"`,
+      `"${tableName}"."${escapeQueryName(refParts[1])}"`,
+      rawJoinSpec.op
+    );
+    joinClauses.push({
+      tableName: joinTableName,
+      joinOn: joinOn,
+      joinType: rawJoinSpec.type.substring(1).replace('_', ' '),
+    });
+  }
+
   private processJoinInfo(
     joinParentTable: string,
     joinInst: Instance,
-    joinsSpec: JoinInfo[],
+    joinInfo: JoinInfo[],
     joinClauses: JoinClause[]
   ) {
-    joinsSpec.forEach((ji: JoinInfo) => {
+    joinInfo.forEach((ji: JoinInfo) => {
       const rel: Relationship = ji.relationship;
       const joinTableName = asTableReference(ji.queryInstance.moduleName, ji.queryInstance.name);
       let joinOn: JoinOn | JoinOn[] | undefined;

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','@distinct','@enum','@expr','@from','@into','@meta','@oneof','@public','@rbac','@ref','@then','@upsert','@with_unique','agent','agentlang/retry','allow','and','attempts','await','backoff','between','case','commitTransaction','contains','create','decision','delete','directive','else','entity','error','event','extends','false','flow','for','glossaryEntry','if','import','in','like','module','not','not_found','onSubscription','or','purge','query','read','record','relationship','resolver','return','roles','rollbackTransaction','scenario','startTransaction','subscribe','true','update','upsert','where','workflow'
+        '@actions','@after','@as','@async','@before','@catch','@distinct','@enum','@expr','@from','@full_join','@inner_join','@into','@join','@left_join','@meta','@oneof','@public','@rbac','@ref','@right_join','@then','@upsert','@with_unique','agent','agentlang/retry','allow','and','attempts','await','backoff','between','case','commitTransaction','contains','create','decision','delete','directive','else','entity','error','event','extends','false','flow','for','glossaryEntry','if','import','in','like','module','not','not_found','onSubscription','or','purge','query','read','record','relationship','resolver','return','roles','rollbackTransaction','scenario','startTransaction','subscribe','true','update','upsert','where','workflow'
     ],
     operators: [
         '!=','*','+',',','-','-->','.','/',':',';','<','<=','<>','=','==','>','>=','?','@'