agentlang 0.0.24 → 0.0.26

package/src/cli/main.ts

@@ -7,8 +7,8 @@ import {
   internModule,
   load,
   loadAppConfig,
-  runPostInitTasks,
-  runPreInitTasks,
+  loadCoreModules,
+  runStandaloneStatements,
 } from '../runtime/loader.js';
 import { NodeFileSystem } from 'langium/node';
 import { extractDocument } from '../runtime/loader.js';
@@ -23,6 +23,9 @@ import { prepareIntegrations } from '../runtime/integrations.js';
 import { isNodeEnv } from '../utils/runtime.js';
 import { OpenAPIClientAxios } from 'openapi-client-axios';
 import { registerOpenApiModule } from '../runtime/openapi.js';
+import { initDatabase } from '../runtime/resolvers/sqldb/database.js';
+import { runInitFunctions } from '../runtime/util.js';
+import { startServer } from '../api/http.js';
 
 const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
 
@@ -79,7 +82,29 @@ export const parseAndValidate = async (fileName: string): Promise<void> => {
   }
 };
 
+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 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 const runModule = async (fileName: string): Promise<void> => {
+  const r: boolean = await runPreInitTasks();
+  if (!r) {
+    throw new Error('Failed to initialize runtime');
+  }
   const configDir =
     path.dirname(fileName) === '.' ? process.cwd() : path.resolve(process.cwd(), fileName);
   const config: Config = await loadAppConfig(configDir);

package/src/runtime/loader.ts

@@ -51,7 +51,6 @@ import {
   makeFqName,
   maybeExtends,
   registerInitFunction,
-  runInitFunctions,
 } from './util.js';
 import { getFileSystem, toFsPath, readFile, readdir, exists } from '../utils/fs-utils.js';
 import { URI } from 'vscode-uri';
@@ -69,8 +68,6 @@ import { Config, ConfigSchema, setAppConfig } from './state.js';
 import { getModuleFn, importModule } from './jsmodules.js';
 import { SetSubscription } from './defs.js';
 import { ExtendedFileSystem } from '../utils/fs/interfaces.js';
-import { initDatabase } from './resolvers/sqldb/database.js';
-import { startServer } from '../api/http.js';
 import z from 'zod';
 
 export async function extractDocument(
@@ -250,34 +247,7 @@ export async function flushAllAndLoad(
   return await load(fileName, fsOptions, callback);
 }
 
-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 async function loadAppConfig(
-  configDir: string,
-  runPreInit: boolean = true
-): Promise<Config> {
-  if (runPreInit) {
-    const r: boolean = await runPreInitTasks();
-    if (!r) {
-      throw new Error('Failed to initialize runtime');
-    }
-  }
+export async function loadAppConfig(configDir: string): Promise<Config> {
   let cfgObj: any = undefined;
   const fs = await getFileSystem();
   const alCfgFile = `${configDir}/config.al`;

package/src/runtime/module.ts

@@ -41,6 +41,7 @@ import {
   isPath,
   findUqCompositeAttributes,
   escapeFqName,
+  encryptPassword,
 } from './util.js';
 import { parseStatement } from '../language/parser.js';
 import { ActiveSessionInfo, AdminSession } from './auth/defs.js';
@@ -1572,6 +1573,7 @@ const builtInChecks = new Map([
   ['UUID', isString],
   ['URL', isString],
   ['Path', isPath],
+  ['Password', isString],
   [
     'Map',
     (obj: any) => {
@@ -1659,6 +1661,19 @@ export function defaultAttributes(schema: RecordSchema): Map<string, any> {
   return result;
 }
 
+export function passwordAttributes(schema: RecordSchema): Set<string> | undefined {
+  let result: Set<string> | undefined = undefined;
+  schema.forEach((v: AttributeSpec, k: string) => {
+    if (v.type == 'Password') {
+      if (result == undefined) {
+        result = new Set<string>();
+      }
+      result?.add(k);
+    }
+  });
+  return result;
+}
+
 export function objectAttributes(schema: RecordSchema): Array<string> | undefined {
   let result: Array<string> | undefined;
   schema.forEach((v: AttributeSpec, k: string) => {
@@ -2297,6 +2312,12 @@ export class Instance {
     return Object.fromEntries(result);
   }
 
+  static fromObject(name: string, moduleName: string, obj: object): Instance {
+    const inst = Instance.EmptyInstance(name, moduleName);
+    const attrs = new Map(Object.entries(obj));
+    return Instance.newWithAttributes(inst, attrs);
+  }
+
   static asSerializableValue(v: any, forSerialization: boolean): any {
     if (v instanceof Instance) {
       const inst = v as Instance;
@@ -2320,9 +2341,9 @@ export class Instance {
     return Object.fromEntries(attrs);
   }
 
-  attributesWithStringifiedObjects(): object {
+  static stringifyObjects(attributes: InstanceAttributes): object {
     const attrs = newInstanceAttributes();
-    this.attributes.forEach((v: any, k: string) => {
+    attributes.forEach((v: any, k: string) => {
       if (v instanceof Object) {
         attrs.set(k, JSON.stringify(v instanceof Map ? Object.fromEntries(v) : v));
       } else {
@@ -2332,6 +2353,10 @@ export class Instance {
     return Object.fromEntries(attrs);
   }
 
+  attributesWithStringifiedObjects(): object {
+    return Instance.stringifyObjects(this.attributes);
+  }
+
   queryAttributesAsObject(): object {
     if (this.queryAttributes != undefined) {
       return Object.fromEntries(this.queryAttributes);
@@ -2522,6 +2547,22 @@ function maybeSetDefaultAttributeValues(
   return attributes;
 }
 
+function postProcessAttributes(
+  schema: RecordSchema,
+  attributes: InstanceAttributes
+): InstanceAttributes {
+  const pswdAttrs = passwordAttributes(schema);
+  if (pswdAttrs) {
+    pswdAttrs.forEach((n: string) => {
+      const v: string | undefined = attributes.get(n);
+      if (v) {
+        attributes.set(n, encryptPassword(v));
+      }
+    });
+  }
+  return attributes;
+}
+
 export function makeInstance(
   moduleName: string,
   entryName: string,
@@ -2544,7 +2585,7 @@ export function makeInstance(
     });
   }
   if (!queryAttributes && !queryAll) {
-    attributes = maybeSetDefaultAttributeValues(schema, attributes);
+    attributes = postProcessAttributes(schema, maybeSetDefaultAttributeValues(schema, attributes));
   }
   return new Instance(
     record,

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

@@ -138,7 +138,7 @@ export class SqlDbResolver extends Resolver {
     const queryVals: object = Object.fromEntries(
       new Map<string, any>().set(PathAttributeName, inst.attributes.get(PathAttributeName))
     );
-    const updateObj: object = Object.fromEntries(newAttrs);
+    const updateObj: object = Instance.stringifyObjects(newAttrs);
     await updateRow(
       asTableReference(inst.moduleName, inst.name),
       queryObj,

package/src/runtime/util.ts

@@ -11,6 +11,8 @@ import {
   Statement,
 } from '../language/generated/ast.js';
 import { readFile } from '../utils/fs-utils.js';
+import bcrypt from 'bcryptjs';
+import path from 'node:path';
 
 export const QuerySuffix = '?';
 
@@ -494,3 +496,23 @@ const ReservedNames = new Set([
 export function isReservedName(s: string): boolean {
   return ReservedNames.has(s);
 }
+
+export function encryptPassword(s: string): string {
+  return bcrypt.hashSync(s, 10);
+}
+
+export function comparePassword(s: string, hash: string): boolean {
+  return bcrypt.compareSync(s, hash);
+}
+
+export function fileExtension(fileName: string): string {
+  if (isNodeEnv) {
+    return path.extname(fileName);
+  } else {
+    const idx = fileName.lastIndexOf('.');
+    if (idx >= 0) {
+      return fileName.substring(idx);
+    }
+  }
+  return '';
+}