agentlang 0.10.1 → 0.10.3

package/src/language/parser.ts

@@ -1,5 +1,6 @@
 import { createAgentlangServices } from '../language/agentlang-module.js';
 import { AstNode, EmptyFileSystem, LangiumCoreServices, LangiumDocument, URI } from 'langium';
+import { getFormattedErrors, collectErrors, formatErrors } from './error-reporter.js';
 import {
   CrudMap,
   Delete,
@@ -19,12 +20,14 @@ import {
   isPrimExpr,
   isWorkflowDefinition,
   JoinSpec,
+  LimitClause,
   Literal,
   MapEntry,
   MapLiteral,
   ModuleDefinition,
   NegExpr,
   NotExpr,
+  OffsetClause,
   OrderByClause,
   Pattern,
   PrimExpr,
@@ -36,9 +39,16 @@ import {
   SetAttribute,
   Statement,
   WhereSpec,
+  WhereSpecClause,
   WorkflowDefinition,
 } from './generated/ast.js';
-import { firstAliasSpec, firstCatchSpec, isString, QuerySuffix } from '../runtime/util.js';
+import {
+  firstAliasSpec,
+  firstCatchSpec,
+  firstEmptySpec,
+  isString,
+  QuerySuffix,
+} from '../runtime/util.js';
 import {
   BasePattern,
   CrudPattern,
@@ -54,6 +64,7 @@ import {
   NegExpressionPattern,
   NotExpressionPattern,
   ReturnPattern,
+  WhereSpecClausePattern,
 } from './syntax.js';
 
 let nextDocumentId = 1;
@@ -116,113 +127,25 @@ export async function parseWorkflow(workflowDef: string): Promise<WorkflowDefini
   }
 }
 
-const ErrorIndicator = '<-- ERROR';
-
 export function maybeGetValidationErrors(
   document: LangiumDocument,
-  lines?: string[]
-): string[] | undefined {
-  if (lines === undefined) {
-    lines = document.textDocument.getText().split('\n');
-  }
+  _lines?: string[]
+): string | undefined {
   const validationErrors = (document.diagnostics ?? []).filter(e => e.severity === 1);
+  if (validationErrors.length === 0) return undefined;
 
-  const sls = new Set<number>();
-  const scs = new Set<number>();
-  if (validationErrors.length > 0) {
-    for (const validationError of validationErrors) {
-      if (
-        !sls.has(validationError.range.start.line) &&
-        !scs.has(validationError.range.start.character)
-      ) {
-        const t = document.textDocument.getText(validationError.range);
-        const s = `(${validationError.range.start.line + 1}:${validationError.range.start.character + 1}) unexpected token(s) '${t}'`;
-        const ln = lines[validationError.range.start.line];
-        if (ln.indexOf(ErrorIndicator) > 0) {
-          lines[validationError.range.start.line] = `${ln}, ${s}`;
-        } else {
-          lines[validationError.range.start.line] = `${ln}    ${ErrorIndicator} ${s}`;
-        }
-        sls.add(validationError.range.start.line);
-        scs.add(validationError.range.start.character);
-      }
-    }
-    return trimErrorLines(lines);
-  } else {
-    return undefined;
-  }
-}
+  // Collect only validation errors (not lexer/parser)
+  const errors = collectErrors(document).filter(e => e.category === 'VALIDATION ERROR');
+  if (errors.length === 0) return undefined;
 
-function trimErrorLines(lines: string[]): string[] {
-  let startidx = 0;
-  for (let i = 0; i < lines.length; ++i) {
-    if (lines[i].indexOf(ErrorIndicator) > 0) {
-      startidx = i;
-      break;
-    }
-  }
-  let endidx = startidx;
-  for (let i = startidx + 1; i < lines.length; ++i) {
-    if (lines[i].indexOf(ErrorIndicator) > 0) {
-      endidx = i;
-      break;
-    }
-  }
-  if (startidx > 0) {
-    --startidx;
-  }
-  if (endidx != lines.length) {
-    ++endidx;
-  }
-  return lines.slice(startidx, endidx);
-}
-
-function trimErrorMessage(s: string): string {
-  const start = s.indexOf('Expecting:');
-  if (start >= 0) {
-    const end = s.indexOf('but found:');
-    if (end > 0) {
-      return `Expecting a valid token sequence, ${s.substring(end)}`;
-    }
-  }
-  return s;
+  const source = document.textDocument.getText();
+  return formatErrors(errors, source);
 }
 
 export function maybeRaiseParserErrors(document: LangiumDocument) {
-  const code = document.textDocument.getText();
-  const lines = code.split('\n');
-  let hasErrors = false;
-  const errLines = new Set<number>();
-  if (document.parseResult.lexerErrors.length > 0) {
-    document.parseResult.lexerErrors.forEach((err: any) => {
-      if (!errLines.has(err.line)) {
-        const errMsg = trimErrorMessage(err.message);
-        const s = `${ErrorIndicator} (${err.line}:${err.column}) ${errMsg}`;
-        lines[err.line - 1] = `${lines[err.line - 1]}    ${s}`;
-        errLines.add(err.line);
-      }
-    });
-    hasErrors = true;
-  }
-  if (document.parseResult.parserErrors.length > 0) {
-    document.parseResult.parserErrors.forEach((err: any) => {
-      const errMsg = trimErrorMessage(err.message);
-      if (err.token.startLine && err.token.endLine) {
-        if (!errLines.has(err.token.startLine)) {
-          const s = `${ErrorIndicator} (${err.token.startLine}:${err.token.startColumn}) ${errMsg}`;
-          lines[err.token.endLine - 1] = `${lines[err.token.endLine - 1]}    ${s}`;
-          lines.join('\n');
-          errLines.add(err.token.startLine);
-        }
-      } else {
-        lines.push(`ERROR: ${errMsg}`);
-      }
-    });
-    hasErrors = true;
-  }
-  const errs = maybeGetValidationErrors(document, lines);
-  if (hasErrors || errs !== undefined) {
-    throw new Error(lines.join('\n'));
+  const formatted = getFormattedErrors(document);
+  if (formatted) {
+    throw new Error('\n' + formatted);
   }
 }
 
@@ -262,6 +185,10 @@ function introspectStatement(stmt: Statement): BasePattern {
       r.addHandler(h.except, introspectStatement(h.stmt));
     });
   }
+  const emptySpec = firstEmptySpec(stmt);
+  if (emptySpec) {
+    r.setEmptyHandler(introspectStatement(emptySpec.stmt));
+  }
   return r;
 }
 
@@ -299,6 +226,14 @@ function introspectPattern(pat: Pattern): BasePattern {
 function introspectInto(intoSpec: SelectIntoSpec, p: CrudPattern): CrudPattern {
   intoSpec.entries.forEach((se: SelectIntoEntry) => {
     if (se.attribute) p.addInto(se.alias, se.attribute);
+    else if (se.aggregate) {
+      const args = se.aggregate.args
+        .map((s: string) => {
+          return s;
+        })
+        .join(', ');
+      p.addInto(se.alias, `@${se.aggregate?.name}(${args})`);
+    }
   });
   return p;
 }
@@ -379,6 +314,24 @@ function introspectQueryPattern(crudMap: CrudMap): CrudPattern {
       };
       cp.joins.push(jp);
     });
+    if (opts.where?.clauses) {
+      cp.where = new Array<WhereSpecClausePattern>();
+      opts.where.clauses.forEach((wc: WhereSpecClause) => {
+        cp.where?.push({ lhs: wc.lhs, op: wc.op || '=', rhs: wc.rhs.$cstNode?.text || '' });
+      });
+    }
+    if (opts.groupByClause) {
+      cp.groupBy = opts.groupByClause.colNames;
+    }
+    if (opts.orderByClause) {
+      cp.orderBy = opts.orderByClause.colNames;
+    }
+    if (opts.limitClause) {
+      cp.limit = opts.limitClause.value;
+    }
+    if (opts.offsetClause) {
+      cp.offset = opts.offsetClause.value;
+    }
     cp.isCreate = false;
     cp.isQueryUpdate = false;
     cp.isQuery = true;
@@ -393,6 +346,8 @@ export type ExtractedQueryOptions = {
   where: WhereSpec | undefined;
   groupByClause: GroupByClause | undefined;
   orderByClause: OrderByClause | undefined;
+  limitClause: LimitClause | undefined;
+  offsetClause: OffsetClause | undefined;
   upsert: '@upsert' | undefined;
   distinct: '@distinct' | undefined;
 };
@@ -404,6 +359,8 @@ export function extractQueryOptions(crudMap: CrudMap): ExtractedQueryOptions {
     where: undefined,
     groupByClause: undefined,
     orderByClause: undefined,
+    limitClause: undefined,
+    offsetClause: undefined,
     upsert: undefined,
     distinct: undefined,
   };
@@ -421,6 +378,10 @@ export function extractQueryOptions(crudMap: CrudMap): ExtractedQueryOptions {
       r.groupByClause = qo.groupByClause;
     } else if (qo.orderByClause) {
       r.orderByClause = qo.orderByClause;
+    } else if (qo.limitClause) {
+      r.limitClause = qo.limitClause;
+    } else if (qo.offsetClause) {
+      r.offsetClause = qo.offsetClause;
     } else if (qo.upsert) {
       r.upsert = qo.upsert;
     } else if (qo.distinct) {
@@ -564,7 +525,7 @@ export async function introspectCase(caseStr: string): Promise<CasePattern> {
 
 export function canParse(s: string): boolean {
   const ts = s.trim();
-  if (ts) {
+  if (ts && ts.includes('{')) {
     const contents = ts.substring(1, ts.length - 1).trim();
     return contents.length > 0;
   }
@@ -582,6 +543,8 @@ export function objectToQueryPattern(obj: any): string {
         });
       } else if (k === '@groupBy' || k === '@orderBy') {
         strs.push(`${k} ( ${xs.join(', ')} )`);
+      } else if (k === '@limit' || k === '@offset') {
+        strs.push(`${k}(${xs})`);
       } else {
         strs.push(`${k} ${objectToQuerySpecPattern(xs, true)}`);
       }

package/src/language/syntax.ts

@@ -15,6 +15,7 @@ export class BasePattern {
   alias: string | undefined;
   aliases: string[] | undefined;
   handlers: Map<string, BasePattern> | undefined;
+  emptyHandler: BasePattern | undefined;
 
   setAlias(alias: string) {
     this.alias = alias;
@@ -44,6 +45,11 @@ export class BasePattern {
     this.handlers.set(k, handler);
   }
 
+  setEmptyHandler(handler: BasePattern) {
+    this.emptyHandler = handler;
+    return this;
+  }
+
   private aliasesAsString(): string | undefined {
     if (this.alias) {
       return ` @as ${this.alias}`;
@@ -54,24 +60,30 @@ export class BasePattern {
     }
   }
 
+  private emptyHandlerAsString(): string | undefined {
+    if (this.emptyHandler) {
+      return ` @empty ${this.emptyHandler.toString()}`;
+    }
+    return undefined;
+  }
+
   private handlersAsString(): string | undefined {
-    if (this.handlers) {
-      let s = '{';
+    if (this.handlers && this.handlers.size > 0) {
+      let s = ' @catch {';
       this.handlers.forEach((handler: BasePattern, k: string) => {
-        s = `${s} ${k} ${handler.toString()}\n`;
+        s = `${s}${k} ${handler.toString()} `;
       });
-      return s + '}';
-    } else {
-      return undefined;
+      return s.trimEnd() + '}';
     }
+    return undefined;
   }
+
   hintsAsString(): string {
-    const a = this.aliasesAsString();
-    const h = this.handlersAsString();
-    if (!a && !h) return '';
-    if (a && !h) return a;
-    if (!a && h) return h;
-    return `${a}\n${h}`;
+    // Order matters: @as, then @catch, then @empty (must be last because it's greedy in the grammar)
+    const a = this.aliasesAsString() ?? '';
+    const h = this.handlersAsString() ?? '';
+    const e = this.emptyHandlerAsString() ?? '';
+    return `${a}${h}${e}`;
   }
 
   toString(): string {
@@ -386,12 +398,23 @@ function joinPatternToString(jp: JoinPattern): string {
   return `${jp.type} ${jp.targetEntity} {${jp.conditionLhs}${opr} ${jp.conditionRhs}}`;
 }
 
+export type WhereSpecClausePattern = {
+  lhs: string;
+  op: string;
+  rhs: string;
+};
+
 export class CrudPattern extends BasePattern {
   recordName: string;
   attributes: Array<AttributePattern>;
   relationships: Map<string, CrudPattern[] | CrudPattern> | undefined;
   joins: JoinPattern[];
   into: Map<string, string> | undefined;
+  where: WhereSpecClausePattern[] | undefined;
+  groupBy: string[] | undefined;
+  orderBy: string[] | undefined;
+  limit: number | undefined;
+  offset: number | undefined;
   isQuery: boolean = false;
   isQueryUpdate: boolean = false;
   isCreate: boolean = false;
@@ -521,15 +544,29 @@ export class CrudPattern extends BasePattern {
     return escapeQueryName(this.recordName);
   }
 
-  private intoAsString(): string | undefined {
-    if (this.into) {
-      const ss = new Array<string>();
-      this.into.forEach((attr: string, alias: string) => {
-        ss.push(`${alias} ${attr}`);
-      });
-      return `@into { ${ss.join(',\n')} }`;
-    }
-    return undefined;
+  private intoAsString(): string {
+    const ss = new Array<string>();
+    this.into?.forEach((attr: string, alias: string) => {
+      ss.push(`${alias} ${attr}`);
+    });
+    return `@into { ${ss.join(',\n')} }`;
+  }
+
+  private whereAsString(): string {
+    const ss = new Array<string>();
+    this.where?.forEach((wc: WhereSpecClausePattern) => {
+      if (wc.op == '=') ss.push(`${wc.lhs} ${wc.rhs}`);
+      else ss.push(`${wc.lhs} ${wc.op} ${wc.rhs}`);
+    });
+    return `@where {${ss.join(`,\n`)}}`;
+  }
+
+  private groupByAsString(): string {
+    return `@groupBy(${this.groupBy?.join(', ')})`;
+  }
+
+  private orderByAsString(): string {
+    return `@orderBy(${this.orderBy?.join(', ')})`;
   }
 
   override toString(): string {
@@ -542,10 +579,28 @@ export class CrudPattern extends BasePattern {
       const js = this.joins.map(joinPatternToString);
       s = s.concat(`,\n${js.join(',\n')}`);
     }
-    const ins = this.intoAsString();
-    if (ins) {
-      s = s.concat(`,\n${ins}`);
+    if (this.into) {
+      const ins = this.intoAsString();
+      if (ins) {
+        s = s.concat(`,\n${ins}`);
+      }
+    }
+    if (this.where) {
+      s = s.concat(`,\n${this.whereAsString()}`);
+    }
+    if (this.groupBy) {
+      s = s.concat(`,\n${this.groupByAsString()}`);
     }
+    if (this.orderBy) {
+      s = s.concat(`,\n${this.orderByAsString()}`);
+    }
+    if (this.limit !== undefined) {
+      s = s.concat(`,\n@limit(${this.limit})`);
+    }
+    if (this.offset !== undefined) {
+      s = s.concat(`,\n@offset(${this.offset})`);
+    }
+
     return s.concat('}', this.hintsAsString());
   }
 }

package/src/runtime/api.ts

@@ -1,13 +1,23 @@
 import { fetchConfig as al_fetchConfig } from './interpreter.js';
+import { defaultDataSource } from './resolvers/sqldb/database.js';
 import {
   makeInstance as al_makeInstance,
   isInstanceOfType as al_isInstanceOfType,
 } from './module.js';
 import { getLocalEnv as al_getLocalEnv, setLocalEnv as al_setLocalEnv } from './auth/defs.js';
 import { now } from './util.js';
+import { initDateFns } from './datefns.js';
+import {
+  integrationAuthFetch as al_authFetch,
+  getIntegrationAuthHeaders as al_getAuthHeaders,
+  getOAuthAuthorizeUrl as al_getOAuthAuthorizeUrl,
+  exchangeOAuthCode as al_exchangeOAuthCode,
+  getIntegrationAccessToken as al_getAccessToken,
+} from './integration-client.js';
 
 declare global {
   var agentlang: any | undefined;
+  var dateFns: ReturnType<typeof initDateFns> | undefined;
   function getLocalEnv(k: string, defaultValue?: string): string | undefined;
   function setLocalEnv(k: string, v: string): string;
   function uuid(): string;
@@ -32,6 +42,32 @@ export function initGlobalApi() {
     globalThis.getLocalEnv = al_getLocalEnv;
     globalThis.setLocalEnv = al_setLocalEnv;
 
+    // Expose date-fns functions globally as dateFns.*
+    globalThis.dateFns = initDateFns();
+
+    // Expose credential auth helpers globally
+    globalThis.agentlang.authFetch = al_authFetch;
+    globalThis.agentlang.getAuthHeaders = al_getAuthHeaders;
+
+    // Expose OAuth consent flow helpers globally
+    globalThis.agentlang.getOAuthAuthorizeUrl = al_getOAuthAuthorizeUrl;
+    globalThis.agentlang.exchangeOAuthCode = al_exchangeOAuthCode;
+    globalThis.agentlang.getAccessToken = al_getAccessToken;
+
+    // Expose raw SQL query for resolvers that need direct database access (e.g. pgvector)
+    globalThis.agentlang.rawQuery = async (sql: string, params?: any[]) => {
+      if (!defaultDataSource || !defaultDataSource.isInitialized) {
+        throw new Error('Database not initialized');
+      }
+      return defaultDataSource.query(sql, params);
+    };
+
+    // Expose database type detection for resolvers
+    globalThis.agentlang.getDbType = () => {
+      if (!defaultDataSource || !defaultDataSource.isInitialized) return 'unknown';
+      return defaultDataSource.options.type;
+    };
+
     ApiInited = true;
   }
 }

package/src/runtime/datefns.ts

@@ -0,0 +1,112 @@
+import {
+  addDays as _addDays,
+  addWeeks as _addWeeks,
+  addMonths as _addMonths,
+  startOfWeek as _startOfWeek,
+  endOfWeek as _endOfWeek,
+  startOfMonth as _startOfMonth,
+  endOfMonth as _endOfMonth,
+  getISOWeek,
+  format,
+  parse,
+  differenceInDays,
+  differenceInWeeks,
+} from 'date-fns';
+import { formatInTimeZone } from 'date-fns-tz';
+
+/**
+ * Parse a date string as local midnight to avoid timezone day-shift issues.
+ * date-fns operates in local time, so we must parse date-only strings
+ * (YYYY-MM-DD) as local midnight rather than UTC midnight.
+ */
+function toDate(dateStr: string): Date {
+  if (!dateStr.includes('T')) {
+    const [y, m, d] = dateStr.split('-').map(Number);
+    return new Date(y, m - 1, d);
+  }
+  return new Date(dateStr);
+}
+
+function toDateStr(d: Date): string {
+  return format(d, 'yyyy-MM-dd');
+}
+
+function addDays(dateStr: string, days: number): string {
+  return toDateStr(_addDays(toDate(dateStr), days));
+}
+
+function addWeeks(dateStr: string, weeks: number): string {
+  return toDateStr(_addWeeks(toDate(dateStr), weeks));
+}
+
+function addMonths(dateStr: string, months: number): string {
+  return toDateStr(_addMonths(toDate(dateStr), months));
+}
+
+function startOfWeek(dateStr: string): string {
+  return toDateStr(_startOfWeek(toDate(dateStr), { weekStartsOn: 1 }));
+}
+
+function endOfWeek(dateStr: string): string {
+  return toDateStr(_endOfWeek(toDate(dateStr), { weekStartsOn: 1 }));
+}
+
+function startOfMonth(dateStr: string): string {
+  return toDateStr(_startOfMonth(toDate(dateStr)));
+}
+
+function endOfMonth(dateStr: string): string {
+  return toDateStr(_endOfMonth(toDate(dateStr)));
+}
+
+function getWeek(dateStr: string): number {
+  return getISOWeek(toDate(dateStr));
+}
+
+function dayName(dateStr: string): string {
+  return format(toDate(dateStr), 'EEEE');
+}
+
+function formatDate(dateStr: string, fmt: string): string {
+  return format(toDate(dateStr), fmt);
+}
+
+function parseDate(str: string, fmt: string): string {
+  return toDateStr(parse(str, fmt, new Date()));
+}
+
+function diffInDays(dateStr1: string, dateStr2: string): number {
+  return differenceInDays(toDate(dateStr1), toDate(dateStr2));
+}
+
+function diffInWeeks(dateStr1: string, dateStr2: string): number {
+  return differenceInWeeks(toDate(dateStr1), toDate(dateStr2));
+}
+
+function today(): string {
+  return toDateStr(new Date());
+}
+
+function toTimezone(dateStr: string, tz: string): string {
+  return formatInTimeZone(new Date(dateStr), tz, 'yyyy-MM-dd HH:mm:ssXXX');
+}
+
+export function initDateFns() {
+  return {
+    addDays,
+    addWeeks,
+    addMonths,
+    startOfWeek,
+    endOfWeek,
+    startOfMonth,
+    endOfMonth,
+    getWeek,
+    dayName,
+    formatDate,
+    parseDate,
+    diffInDays,
+    diffInWeeks,
+    today,
+    toTimezone,
+  };
+}

package/src/runtime/defs.ts

@@ -4,7 +4,8 @@ export const PathAttributeName: string = '__path__';
 export const PathAttributeNameQuery: string = '__path__?';
 export const ParentAttributeName: string = '__parent__';
 export const DeletedFlagAttributeName: string = '__is_deleted__';
-export const TenantAttributeName: string = '__tenant__';
+export const AgentIdAttributeName: string = 'agentId';
+export const TenantAttributeName: string = 'agentId';
 
 export function isPathAttribute(n: string): boolean {
   return n.startsWith(PathAttributeName);