agentlang 0.0.2

package/src/api/http.ts

@@ -0,0 +1,361 @@
+import chalk from 'chalk';
+import express, { Request, Response } from 'express';
+import {
+  getAllChildRelationships,
+  getAllEntityNames,
+  getAllEventNames,
+  Instance,
+  InstanceAttributes,
+  makeInstance,
+  objectAsInstanceAttributes,
+  Relationship,
+} from '../runtime/module.js';
+import { evaluate, parseAndEvaluateStatement, Result } from '../runtime/interpreter.js';
+import { ApplicationSpec } from '../runtime/loader.js';
+import { logger } from '../runtime/logger.js';
+import { requireAuth, verifySession } from '../runtime/modules/auth.js';
+import { ActiveSessionInfo, BypassSession, isNoSession, NoSession } from '../runtime/auth/defs.js';
+import {
+  escapeFqName,
+  forceAsEscapedName,
+  forceAsFqName,
+  isString,
+  makeFqName,
+  restoreFqName,
+  splitFqName,
+  walkDownInstancePath,
+} from '../runtime/util.js';
+import { BadRequestError, PathAttributeNameQuery, UnauthorisedError } from '../runtime/defs.js';
+
+export function startServer(appSpec: ApplicationSpec, port: number) {
+  const app = express();
+  app.use(express.json());
+
+  const appName: string = appSpec.name;
+  const appVersion: string = appSpec.version;
+
+  app.get('/', (req: Request, res: Response) => {
+    res.send(appName);
+  });
+
+  getAllEventNames().forEach((eventNames: string[], moduleName: string) => {
+    eventNames.forEach((n: string) => {
+      app.post(`/${moduleName}/${n}`, (req: Request, res: Response) => {
+        handleEventPost(moduleName, n, req, res);
+      });
+    });
+  });
+
+  getAllEntityNames().forEach((entityNames: string[], moduleName: string) => {
+    entityNames.forEach((n: string) => {
+      app.get(`/${moduleName}/${n}`, (req: Request, res: Response) => {
+        handleEntityGet(moduleName, n, req, res);
+      });
+      app.get(`/${moduleName}/${n}/*path`, (req: Request, res: Response) => {
+        handleEntityGet(moduleName, n, req, res);
+      });
+      app.post(`/${moduleName}/${n}`, (req: Request, res: Response) => {
+        handleEntityPost(moduleName, n, req, res);
+      });
+      app.post(`/${moduleName}/${n}/*path`, (req: Request, res: Response) => {
+        handleEntityPost(moduleName, n, req, res);
+      });
+      app.put(`/${moduleName}/${n}/*path`, (req: Request, res: Response) => {
+        handleEntityPut(moduleName, n, req, res);
+      });
+      app.delete(`/${moduleName}/${n}/*path`, (req: Request, res: Response) => {
+        handleEntityDelete(moduleName, n, req, res);
+      });
+    });
+  });
+
+  app.listen(port, () => {
+    console.log(
+      chalk.green(
+        `Application ${chalk.bold(appName + ' version ' + appVersion)} started on port ${chalk.bold(port)}`
+      )
+    );
+  });
+}
+
+function ok(res: Response) {
+  return (value: Result) => {
+    const result: Result = normalizedResult(value);
+    res.contentType('application/json');
+    res.send(JSON.stringify(result));
+  };
+}
+
+function statusFromErrorType(err: any): number {
+  if (err instanceof UnauthorisedError) {
+    return 401;
+  } else if (err instanceof BadRequestError) {
+    return 400;
+  } else {
+    return 500;
+  }
+}
+
+function internalError(res: Response) {
+  return (reason: any) => {
+    logger.error(reason);
+    res.status(statusFromErrorType(reason)).send(reason.message);
+  };
+}
+
+function patternFromAttributes(
+  moduleName: string,
+  recName: string,
+  attrs: InstanceAttributes
+): string {
+  const attrsStrs = new Array<string>();
+  attrs.forEach((v: any, n: string) => {
+    let av = isString(v) ? `"${v}"` : v;
+    if (av instanceof Object) {
+      av = JSON.stringify(av);
+    }
+    attrsStrs.push(`${n} ${av}`);
+  });
+  return `{${moduleName}/${recName} { ${attrsStrs.join(',\n')} }}`;
+}
+
+function normalizeRequestPath(path: string[], moduleName: string): string[] {
+  if (path.length <= 1) {
+    return path;
+  }
+  const result = new Array<string>();
+  result.push(path[0]);
+  for (let i = 1; i < path.length; ++i) {
+    const rn = forceAsEscapedName(path[i], moduleName);
+    const en = forceAsEscapedName(path[++i], moduleName);
+    result.push(rn);
+    result.push(en);
+    if (i < path.length) {
+      result.push(path[++i]);
+    }
+  }
+  return result;
+}
+
+function pathFromRequest(moduleName: string, entryName: string, req: Request): string {
+  const path: any = req.params.path;
+  if (!path) {
+    return req.url;
+  }
+  let p = '';
+  if (path instanceof Array) {
+    p = normalizeRequestPath(path, moduleName).join('/');
+  } else {
+    p = path.toString();
+  }
+  p = p.trim();
+  if (p.endsWith('/')) {
+    p = p.substring(0, p.length - 1);
+  }
+  return `${escapeFqName(makeFqName(moduleName, entryName))}/${p}`;
+}
+
+async function handleEventPost(
+  moduleName: string,
+  eventName: string,
+  req: Request,
+  res: Response
+): Promise<void> {
+  try {
+    const sessionInfo = await verifyAuth(moduleName, eventName, req.headers.authorization);
+    if (isNoSession(sessionInfo)) {
+      res.status(401).send('Authorization required');
+      return;
+    }
+    const inst: Instance = makeInstance(
+      moduleName,
+      eventName,
+      objectAsInstanceAttributes(req.body)
+    ).setAuthContext(sessionInfo);
+    evaluate(inst, ok(res)).catch(internalError(res));
+  } catch (err: any) {
+    logger.error(err);
+    res.status(500).send(err.toString());
+  }
+}
+
+async function handleEntityPost(
+  moduleName: string,
+  entityName: string,
+  req: Request,
+  res: Response
+): Promise<void> {
+  try {
+    const sessionInfo = await verifyAuth(moduleName, entityName, req.headers.authorization);
+    if (isNoSession(sessionInfo)) {
+      res.status(401).send('Authorization required');
+      return;
+    }
+    const pattern = req.params.path
+      ? createChildPattern(moduleName, entityName, req)
+      : patternFromAttributes(moduleName, entityName, objectAsInstanceAttributes(req.body));
+    parseAndEvaluateStatement(pattern, sessionInfo.userId).then(ok(res)).catch(internalError(res));
+  } catch (err: any) {
+    logger.error(err);
+    res.status(500).send(err.toString());
+  }
+}
+
+async function handleEntityGet(
+  moduleName: string,
+  entityName: string,
+  req: Request,
+  res: Response
+): Promise<void> {
+  try {
+    const path = pathFromRequest(moduleName, entityName, req);
+    const sessionInfo = await verifyAuth(moduleName, entityName, req.headers.authorization);
+    if (isNoSession(sessionInfo)) {
+      res.status(401).send('Authorization required');
+      return;
+    }
+    let pattern = '';
+    if (req.query.tree) {
+      pattern = fetchTreePattern(makeFqName(moduleName, entityName), path);
+    } else {
+      const r = walkDownInstancePath(path);
+      let moduleName = r[0];
+      let entityName = r[1];
+      const id = r[2];
+      const parts = r[3];
+      if (parts.length == 2 && id == undefined) {
+        pattern = `{${moduleName}/${entityName}? {}}`;
+      } else {
+        moduleName = restoreFqName(moduleName);
+        entityName = restoreFqName(entityName);
+        if (id == undefined) {
+          pattern = `{${moduleName}/${entityName} {${PathAttributeNameQuery}like "${path}%"}}`;
+        } else {
+          pattern = `{${moduleName}/${entityName} {${PathAttributeNameQuery} "${path}"}}`;
+        }
+      }
+    }
+    parseAndEvaluateStatement(pattern, sessionInfo.userId).then(ok(res)).catch(internalError(res));
+  } catch (err: any) {
+    logger.error(err);
+    res.status(500).send(err.toString());
+  }
+}
+
+async function handleEntityPut(
+  moduleName: string,
+  entityName: string,
+  req: Request,
+  res: Response
+): Promise<void> {
+  try {
+    const path = pathFromRequest(moduleName, entityName, req);
+    const sessionInfo = await verifyAuth(moduleName, entityName, req.headers.authorization);
+    if (isNoSession(sessionInfo)) {
+      res.status(401).send('Authorization required');
+      return;
+    }
+    const attrs = objectAsInstanceAttributes(req.body);
+    attrs.set(PathAttributeNameQuery, path);
+    const pattern = patternFromAttributes(moduleName, entityName, attrs);
+    parseAndEvaluateStatement(pattern, sessionInfo.userId).then(ok(res)).catch(internalError(res));
+  } catch (err: any) {
+    logger.error(err);
+    res.status(500).send(err.toString());
+  }
+}
+
+async function handleEntityDelete(
+  moduleName: string,
+  entityName: string,
+  req: Request,
+  res: Response
+): Promise<void> {
+  try {
+    const path = pathFromRequest(moduleName, entityName, req);
+    const sessionInfo = await verifyAuth(moduleName, entityName, req.headers.authorization);
+    if (isNoSession(sessionInfo)) {
+      res.status(401).send('Authorization required');
+      return;
+    }
+    const pattern = `delete {${moduleName}/${entityName} {${PathAttributeNameQuery} "${path}"}}`;
+    parseAndEvaluateStatement(pattern, sessionInfo.userId).then(ok(res)).catch(internalError(res));
+  } catch (err: any) {
+    logger.error(err);
+    res.status(500).send(err.toString());
+  }
+}
+
+function fetchTreePattern(fqName: string, path?: string): string {
+  let pattern = path ? `{${fqName} {${PathAttributeNameQuery} "${path}"}` : `{${fqName}? {}`;
+  const rels = getAllChildRelationships(fqName);
+  if (rels.length > 0) {
+    const treePats = new Array<string>();
+    rels.forEach((rel: Relationship) => {
+      treePats.push(`${rel.getFqName()} ${fetchTreePattern(rel.getChildFqName())}`);
+    });
+    pattern = pattern.concat(',', treePats.join(','));
+  }
+  return `${pattern}}`;
+}
+
+function createChildPattern(moduleName: string, entityName: string, req: Request): string {
+  const path = pathFromRequest(moduleName, entityName, req);
+  try {
+    const parts = path.split('/');
+    const pinfo = parts.slice(-4);
+    const parentFqname = forceAsFqName(pinfo[0], moduleName);
+    const relName = forceAsFqName(pinfo[2], moduleName);
+    const parentPath = parts.slice(0, parts.length - 2).join('/');
+    const childFqName = forceAsFqName(pinfo[3], moduleName);
+    const cparts = splitFqName(childFqName);
+    const childModuleName = cparts.getModuleName();
+    const childName = cparts.getEntryName();
+    const cp = patternFromAttributes(
+      childModuleName,
+      childName,
+      objectAsInstanceAttributes(req.body)
+    );
+    return `{${parentFqname} {${PathAttributeNameQuery} "${parentPath}"}, ${relName} ${cp}}`;
+  } catch (err: any) {
+    throw new BadRequestError(err.message);
+  }
+}
+
+async function verifyAuth(
+  moduleName: string,
+  eventName: string,
+  authValue: string | undefined
+): Promise<ActiveSessionInfo> {
+  if (requireAuth(moduleName, eventName)) {
+    if (authValue) {
+      const token = authValue.substring(authValue.indexOf(' ')).trim();
+      return await verifySession(token);
+    } else {
+      return NoSession;
+    }
+  }
+  return BypassSession;
+}
+
+function normalizedResult(r: Result): Result {
+  if (r instanceof Array) {
+    return r.map((x: Result) => {
+      return normalizedResult(x);
+    });
+  } else if (r instanceof Instance) {
+    r.mergeRelatedInstances();
+    Array.from(r.attributes.keys()).forEach(k => {
+      const v: Result = r.attributes.get(k);
+      if (v instanceof Array || v instanceof Instance) {
+        r.attributes.set(k, normalizedResult(v));
+      }
+    });
+    return r.asObject();
+  } else {
+    if (r instanceof Map) {
+      return Object.fromEntries(r.entries());
+    }
+    return r;
+  }
+}

package/src/cli/cli-util.ts

@@ -0,0 +1,18 @@
+import { path } from '../utils/runtime.js';
+
+interface FilePathData {
+  destination: string;
+  name: string;
+}
+
+export function extractDestinationAndName(
+  filePath: string,
+  destination: string | undefined
+): FilePathData {
+  const fileName = path.basename(filePath, path.extname(filePath)).replace(/[.-]/g, '');
+
+  return {
+    destination: destination ?? path.join(path.dirname(filePath), 'generated'),
+    name: fileName,
+  };
+}

package/src/cli/main.ts

@@ -0,0 +1,146 @@
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { AgentlangLanguageMetaData } from '../language/generated/module.js';
+import { createAgentlangServices } from '../language/agentlang-module.js';
+import {
+  ApplicationSpec,
+  internModule,
+  load,
+  loadCoreModules,
+  runStandaloneStatements,
+} from '../runtime/loader.js';
+import { NodeFileSystem } from 'langium/node';
+import { extractDocument } from '../runtime/loader.js';
+import * as url from 'node:url';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { startServer } from '../api/http.js';
+import { initDatabase } from '../runtime/resolvers/sqldb/database.js';
+import { logger } from '../runtime/logger.js';
+import { runInitFunctions } from '../runtime/util.js';
+import { Module } from '../runtime/module.js';
+import { ModuleDefinition } from '../language/generated/ast.js';
+import { z } from 'zod';
+import { loadConfig } from 'c12';
+import { Config, ConfigSchema, setAppConfig } from '../runtime/state.js';
+
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
+
+const packagePath = path.resolve(__dirname, '..', '..', 'package.json');
+const packageContent = await fs.readFile(packagePath, 'utf-8');
+
+export type GenerateOptions = {
+  destination?: string;
+};
+
+export default function (): void {
+  const program = new Command();
+
+  program.version(JSON.parse(packageContent).version);
+
+  const fileExtensions = AgentlangLanguageMetaData.fileExtensions.join(', ');
+
+  program
+    .command('run')
+    .argument('<file>', `source file (possible file extensions: ${fileExtensions})`)
+    .option('-c, --config <config>', 'configuration file')
+    .description('Loads and runs an agentlang module')
+    .action(runModule);
+
+  program
+    .command('parseAndValidate')
+    .argument('<file>', `source file (possible file extensions: ${fileExtensions})`)
+    .option('-d, --destination <dir>', 'destination directory of generating')
+    .description('Parses and validates an Agentlang module')
+    .action(parseAndValidate);
+
+  program.parse(process.argv);
+}
+
+/**
+ * Parse and validate a program written in our language.
+ * Verifies that no lexer or parser errors occur.
+ * Implicitly also checks for validation errors while extracting the document
+ *
+ * @param fileName Program to validate
+ */
+export const parseAndValidate = async (fileName: string): Promise<void> => {
+  // retrieve the services for our language
+  const services = createAgentlangServices(NodeFileSystem).Agentlang;
+  // extract a document for our program
+  const document = await extractDocument(fileName, services);
+  // extract the parse result details
+  const parseResult = document.parseResult;
+  // verify no lexer, parser, or general diagnostic errors show up
+  if (parseResult.lexerErrors.length === 0 && parseResult.parserErrors.length === 0) {
+    console.log(chalk.green(`Parsed and validated ${fileName} successfully!`));
+  } else {
+    console.log(chalk.red(`Failed to parse and validate ${fileName}!`));
+  }
+};
+
+export async function runPreInitTasks(): Promise<boolean> {
+  let result: boolean = true;
+  await loadCoreModules().catch((reason: any) => {
+    const msg = `Failed to load core modules - ${reason.toString()}`;
+    logger.error(msg);
+    console.log(chalk.red(msg));
+    result = false;
+  });
+  return result;
+}
+
+export async function runPostInitTasks(appSpec?: ApplicationSpec, config?: Config) {
+  await initDatabase(config?.store);
+  await runInitFunctions();
+  await runStandaloneStatements();
+  if (appSpec) startServer(appSpec, config?.service?.port || 8080);
+}
+
+export const runModule = async (fileName: string, options?: { config?: string }): Promise<void> => {
+  const configDir =
+    path.dirname(fileName) === '.' ? process.cwd() : path.resolve(process.cwd(), fileName);
+
+  let config: Config | undefined;
+
+  try {
+    const { config: rawConfig } = await loadConfig({
+      cwd: configDir,
+      name: 'config',
+      configFile: options?.config || 'app.config',
+      dotenv: true,
+    });
+
+    config = setAppConfig(ConfigSchema.parse(rawConfig));
+  } catch (err) {
+    if (err instanceof z.ZodError) {
+      console.log(chalk.red('Config validation failed:'));
+      err.errors.forEach((error, index) => {
+        console.log(chalk.red(`  ${index + 1}. ${error.path.join('.')}: ${error.message}`));
+      });
+    } else {
+      console.log(`Config loading failed: ${err}`);
+    }
+  }
+
+  const r: boolean = await runPreInitTasks();
+  if (!r) {
+    throw new Error('Failed to initialize runtime');
+  }
+  await load(fileName, undefined, async (appSpec?: ApplicationSpec) => {
+    await runPostInitTasks(appSpec, config);
+  });
+};
+
+export async function internAndRunModule(
+  module: ModuleDefinition,
+  appSpec?: ApplicationSpec
+): Promise<Module> {
+  const r: boolean = await runPreInitTasks();
+  if (!r) {
+    throw new Error('Failed to initialize runtime');
+  }
+  const rm: Module = internModule(module);
+  await runPostInitTasks(appSpec);
+  return rm;
+}

package/src/extension/main.ts

@@ -0,0 +1,51 @@
+import type { LanguageClientOptions, ServerOptions } from 'vscode-languageclient/node.js';
+import type * as vscode from 'vscode';
+import * as path from 'node:path';
+import { LanguageClient, TransportKind } from 'vscode-languageclient/node.js';
+
+let client: LanguageClient;
+
+// This function is called when the extension is activated.
+export function activate(context: vscode.ExtensionContext): void {
+  client = startLanguageClient(context);
+}
+
+// This function is called when the extension is deactivated.
+export function deactivate(): Thenable<void> | undefined {
+  if (client) {
+    return client.stop();
+  }
+  return undefined;
+}
+
+function startLanguageClient(context: vscode.ExtensionContext): LanguageClient {
+  const serverModule = context.asAbsolutePath(path.join('out', 'language', 'main.cjs'));
+  // The debug options for the server
+  // --inspect=6009: runs the server in Node's Inspector mode so VS Code can attach to the server for debugging.
+  // By setting `process.env.DEBUG_BREAK` to a truthy value, the language server will wait until a debugger is attached.
+  const debugOptions = {
+    execArgv: [
+      '--nolazy',
+      `--inspect${process.env.DEBUG_BREAK ? '-brk' : ''}=${process.env.DEBUG_SOCKET || '6009'}`,
+    ],
+  };
+
+  // If the extension is launched in debug mode then the debug server options are used
+  // Otherwise the run options are used
+  const serverOptions: ServerOptions = {
+    run: { module: serverModule, transport: TransportKind.ipc },
+    debug: { module: serverModule, transport: TransportKind.ipc, options: debugOptions },
+  };
+
+  // Options to control the language client
+  const clientOptions: LanguageClientOptions = {
+    documentSelector: [{ scheme: '*', language: 'agentlang' }],
+  };
+
+  // Create the language client and start the client.
+  const client = new LanguageClient('agentlang', 'Agentlang', serverOptions, clientOptions);
+
+  // Start the client. This will also launch the server
+  client.start();
+  return client;
+}

package/src/language/agentlang-module.ts

@@ -0,0 +1,75 @@
+import { type Module, inject } from 'langium';
+import {
+  createDefaultModule,
+  createDefaultSharedModule,
+  type DefaultSharedModuleContext,
+  type LangiumServices,
+  type LangiumSharedServices,
+  type PartialLangiumServices,
+} from 'langium/lsp';
+import { AgentlangGeneratedModule, AgentlangGeneratedSharedModule } from './generated/module.js';
+import { AgentlangValidator, registerValidationChecks } from './agentlang-validator.js';
+
+/**
+ * Declaration of custom services - add your own service classes here.
+ */
+export type AgentlangAddedServices = {
+  validation: {
+    AgentlangValidator: AgentlangValidator;
+  };
+};
+
+/**
+ * Union of Langium default services and your custom services - use this as constructor parameter
+ * of custom service classes.
+ */
+export type AgentlangServices = LangiumServices & AgentlangAddedServices;
+
+/**
+ * Dependency injection module that overrides Langium default services and contributes the
+ * declared custom services. The Langium defaults can be partially specified to override only
+ * selected services, while the custom services must be fully specified.
+ */
+export const AgentlangModule: Module<
+  AgentlangServices,
+  PartialLangiumServices & AgentlangAddedServices
+> = {
+  validation: {
+    AgentlangValidator: () => new AgentlangValidator(),
+  },
+};
+
+/**
+ * Create the full set of services required by Langium.
+ *
+ * First inject the shared services by merging two modules:
+ *  - Langium default shared services
+ *  - Services generated by langium-cli
+ *
+ * Then inject the language-specific services by merging three modules:
+ *  - Langium default language-specific services
+ *  - Services generated by langium-cli
+ *  - Services specified in this file
+ *
+ * @param context Optional module context with the LSP connection
+ * @returns An object wrapping the shared services and the language-specific services
+ */
+export function createAgentlangServices(context: DefaultSharedModuleContext): {
+  shared: LangiumSharedServices;
+  Agentlang: AgentlangServices;
+} {
+  const shared = inject(createDefaultSharedModule(context), AgentlangGeneratedSharedModule);
+  const Agentlang = inject(
+    createDefaultModule({ shared }),
+    AgentlangGeneratedModule,
+    AgentlangModule
+  );
+  shared.ServiceRegistry.register(Agentlang);
+  registerValidationChecks(Agentlang);
+  if (!context.connection) {
+    // We don't run inside a language server
+    // Therefore, initialize the configuration provider instantly
+    shared.workspace.ConfigurationProvider.initialized({});
+  }
+  return { shared, Agentlang };
+}