agentlang 0.0.6 → 0.0.8

package/src/runtime/interpreter.ts

@@ -731,6 +731,26 @@ async function patternToInstance(
   return makeInstance(moduleName, entryName, attrs, qattrs, qattrVals, isQueryAll);
 }
 
+async function instanceFromSource(crud: CrudMap, env: Environment): Promise<Instance> {
+  if (crud.source) {
+    await evaluateLiteral(crud.source, env);
+    const attrsSrc = env.getLastResult();
+    if (attrsSrc && attrsSrc instanceof Object) {
+      const attrs: InstanceAttributes = new Map(Object.entries(attrsSrc));
+      const nparts = splitFqName(crud.name);
+      const n = nparts.getEntryName();
+      const m = nparts.hasModule() ? nparts.getModuleName() : env.getActiveModuleName();
+      return makeInstance(m, n, attrs);
+    } else {
+      throw new Error(`Failed to initialize instance of ${crud.name}, expected a map after @from.`);
+    }
+  } else {
+    throw new Error(
+      `Cannot create instance of ${crud.name}, CRUD pattern does not specify a source map.`
+    );
+  }
+}
+
 async function maybeValidateOneOfRefs(inst: Instance, env: Environment) {
   const attrs = inst.record.oneOfRefAttributes;
   if (!attrs) return;
@@ -761,10 +781,12 @@ async function maybeValidateOneOfRefs(inst: Instance, env: Environment) {
 }
 
 async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
-  if (!env.isInUpsertMode() && crud.upsert) {
+  if (!env.isInUpsertMode() && crud.upsert.length > 0) {
     return await evaluateUpsert(crud, env);
   }
-  const inst: Instance = await patternToInstance(crud.name, crud.body?.attributes, env);
+  const inst: Instance = crud.source
+    ? await instanceFromSource(crud, env)
+    : await patternToInstance(crud.name, crud.body?.attributes, env);
   const entryName = inst.name;
   const moduleName = inst.moduleName;
   const attrs = inst.attributes;

package/src/runtime/jsmodules.ts

@@ -6,6 +6,9 @@ const importedModules = new Map<string, any>();
 
 // Usage: importModule("./mymodels/acme.js")
 export async function importModule(path: string, name: string) {
+  if (importedModules.has(name)) {
+    logger.warn(`Alias '${name}' will overwrite a previously imported module`);
+  }
   if (!(path.startsWith('/') || path.startsWith('.'))) {
     path = process.cwd() + '/' + path;
   }

package/src/runtime/loader.ts

@@ -50,7 +50,6 @@ import {
   makeFqName,
   maybeExtends,
   registerInitFunction,
-  runShellCommand,
 } from './util.js';
 import { getFileSystem, toFsPath, readFile, readdir, exists } from '../utils/fs-utils.js';
 import { URI } from 'vscode-uri';
@@ -172,7 +171,7 @@ async function loadApp(appDir: string, fsOptions?: any, callback?: Function): Pr
       return;
     }
     directoryContents.forEach(file => {
-      if (path.extname(file) == '.al') {
+      if (path.extname(file).toLowerCase() == '.al') {
         alFiles.push(appDir + path.sep + file);
       }
     });
@@ -182,19 +181,19 @@ async function loadApp(appDir: string, fsOptions?: any, callback?: Function): Pr
     if (callback) await callback(appSpec);
   }
   if (appSpec.dependencies != undefined) {
-    if (isNodeEnv) {
-      // Only run shell commands in Node.js environment
-      for (const [depName, depVer] of Object.entries(appSpec.dependencies)) {
-        runShellCommand(`npm install ${depName}@${depVer}`, undefined, cont2);
+    for (const [depName, _] of Object.entries(appSpec.dependencies)) {
+      const depDirName = `./node_modules/${depName}`;
+      const files = await fs.readdir(depDirName);
+      if (
+        files.find(file => {
+          return path.extname(file).toLowerCase() == '.al';
+        })
+      ) {
+        await loadApp(depDirName, fsOptions);
       }
-    } else {
-      // In non-Node environments, log a warning and continue
-      console.warn('Dependencies cannot be installed in non-Node.js environments');
-      await cont2();
     }
-  } else {
-    await cont2();
   }
+  await cont2();
   return appSpec.name || lastModuleLoaded;
 }
 

package/src/runtime/module.ts

@@ -106,18 +106,43 @@ function recordSchemaToString(scm: RecordSchema): string {
 }
 
 function attributeSpecToString(attrSpec: AttributeSpec): string {
-  let s: string = `${attrSpec.type}`;
+  let s: string = getEnumValues(attrSpec) || getOneOfRef(attrSpec) ? '' : `${attrSpec.type}`;
+  if (isArrayAttribute(attrSpec)) {
+    s = `${s}[]`;
+  }
   if (attrSpec.properties) {
     const ps: Array<string> = [];
     attrSpec.properties.forEach((v: any, k: string) => {
-      if (v == true) ps.push(` @${k}`);
-      else ps.push(` @${k}(${v})`);
+      if (k != 'array') {
+        if (v == true) ps.push(` @${k}`);
+        else ps.push(` @${k}(${attributePropertyValueToString(k, v, attrSpec.type)})`);
+      }
     });
     s = s.concat(ps.join(' '));
   }
   return s;
 }
 
+function attributePropertyValueToString(
+  propName: string,
+  propValue: any,
+  attrType: string
+): string {
+  if (propName == EnumPropertyName) {
+    const v = propValue as Set<string>;
+    const ss = new Array<string>();
+    v.forEach((s: string) => {
+      ss.push(`"${s}"`);
+    });
+    return ss.join(',');
+  } else if (propName == 'default') {
+    if (isTextualType(attrType) && propValue != 'now()' && propValue != 'uuid()') {
+      return `"${propValue}"`;
+    }
+  }
+  return `${propValue}`;
+}
+
 export function newRecordSchema(): RecordSchema {
   return new Map<string, AttributeSpec>();
 }
@@ -178,8 +203,8 @@ function asTriggerInfo(te: TriggerEntry): TriggerInfo {
   };
 }
 
-const EnumPropertyName = 'one-of';
-const OneOfPropertyName = 'one-of-ref';
+const EnumPropertyName = 'enum';
+const OneOfPropertyName = 'oneof';
 
 export function enumAttributeSpec(values: Set<string>): AttributeSpec {
   return {
@@ -1085,6 +1110,13 @@ export class Relationship extends Record {
     const n1 = relNodeEntryToString(this.node1);
     const n2 = relNodeEntryToString(this.node2);
     let s = `relationship ${this.name} ${RelType[this.relType].toLowerCase()} (${n1}, ${n2})`;
+    if (this.isBetween()) {
+      if (this.isOneToOne()) {
+        s = `${s} @${OneToOne}`;
+      } else if (this.isOneToMany()) {
+        s = `${s} @${OneToMany}`;
+      }
+    }
     if (this.getUserAttributes().size > 0) {
       const attrs: Array<string> = [];
       this.getUserAttributes().forEach((attrSpec: AttributeSpec, n: string) => {
@@ -1551,8 +1583,16 @@ export const propertyNames = new Set([
   '@fk',
   '@ref',
   '@readonly',
+  '@enum',
+  '@oneof',
 ]);
 
+const TextualTypes = new Set(['String', 'Email', 'UUID', 'DateTime', 'Date', 'Time', 'Path']);
+
+function isTextualType(type: string): boolean {
+  return TextualTypes.has(type);
+}
+
 export function isBuiltInType(type: string): boolean {
   return builtInTypes.has(type);
 }
@@ -1678,12 +1718,12 @@ export function getAttributeExpr(attrSpec: AttributeSpec): Expr | undefined {
   return getAnyProperty('expr', attrSpec);
 }
 
-export function getOneOfValues(attrSpec: AttributeSpec): Set<string> | undefined {
-  return getAnyProperty('one-of', attrSpec);
+export function getEnumValues(attrSpec: AttributeSpec): Set<string> | undefined {
+  return getAnyProperty(EnumPropertyName, attrSpec);
 }
 
 export function getOneOfRef(attrSpec: AttributeSpec): string | undefined {
-  return getAnyProperty('one-of-ref', attrSpec);
+  return getAnyProperty(OneOfPropertyName, attrSpec);
 }
 
 export function getAttributeDefaultValue(attrSpec: AttributeSpec): any | undefined {
@@ -2034,10 +2074,10 @@ function checkOneOfValue(attrSpec: AttributeSpec, attrName: string, attrValue: a
   if (getOneOfRef(attrSpec)) {
     return true;
   }
-  const vals: Set<string> | undefined = getOneOfValues(attrSpec);
+  const vals: Set<string> | undefined = getEnumValues(attrSpec);
   if (vals) {
     if (!vals.has(attrValue as string)) {
-      throw new Error(`Value of ${attrName} must be one-of ${vals}`);
+      throw new Error(`Value of ${attrName} must be one of ${vals}`);
     }
     return true;
   }
@@ -2341,7 +2381,8 @@ function maybeSetDefaultAttributeValues(
 ): InstanceAttributes {
   const defAttrs = defaultAttributes(schema);
   defAttrs.forEach((v: any, k: string) => {
-    if (!attributes.has(k)) {
+    const cv = attributes.get(k);
+    if (cv == undefined || cv == null) {
       if (isString(v)) {
         if (v == 'uuid()') {
           v = crypto.randomUUID();

package/src/syntaxes/agentlang.monarch.ts

@@ -1,7 +1,7 @@
 // Monarch syntax highlighting for the agentlang language.
 export default {
     keywords: [
-        '@actions','@after','@async','@before','@enum','@expr','@meta','@oneof','@rbac','@ref','@upsert','@with_unique','agent','allow','and','as','await','between','catch','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','roles','subscribe','true','update','upsert','where','workflow'
+        '@actions','@after','@async','@before','@enum','@expr','@from','@meta','@oneof','@rbac','@ref','@upsert','@with_unique','agent','allow','and','as','await','between','catch','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','roles','subscribe','true','update','upsert','where','workflow'
     ],
     operators: [
         '*','+',',','-','.','/',':',';','<','<=','<>','=','>','>=','?','@'