agentlang 0.6.6 → 0.6.7

package/src/runtime/api.ts

@@ -4,6 +4,18 @@ import {
   isInstanceOfType as al_isInstanceOfType,
 } from './module.js';
 
-export const makeInstance = al_makeInstance;
-export const isInstanceOfType = al_isInstanceOfType;
-export const fetchConfig = al_fetchConfig;
+declare global {
+  var agentlang: any | undefined;
+}
+
+let ApiInited = false;
+
+export function initGlobalApi() {
+  if (!ApiInited) {
+    globalThis.agentlang = {};
+    globalThis.agentlang.makeInstance = al_makeInstance;
+    globalThis.agentlang.isInstanceOfType = al_isInstanceOfType;
+    globalThis.agentlang.fetchConfig = al_fetchConfig;
+    ApiInited = true;
+  }
+}

package/src/runtime/defs.ts

@@ -327,3 +327,62 @@ export type FkSpec = {
   onDelete: 'CASCADE' | 'SET NULL' | 'SET DEFAULT' | undefined;
   onUpdate: 'CASCADE' | 'SET NULL' | 'SET DEFAULT' | undefined;
 };
+
+enum RuntimeModeTag {
+  DEV,
+  PROD,
+  INIT_SCHEMA,
+  RUN_MIGRATION,
+  UNDO_MIGRATION,
+  GENERATE_MIGRATION,
+}
+
+let RuntimeMode: RuntimeModeTag = RuntimeModeTag.DEV;
+
+export function setRuntimeMode_dev() {
+  RuntimeMode = RuntimeModeTag.DEV;
+}
+
+export function setRuntimeMode_prod() {
+  RuntimeMode = RuntimeModeTag.PROD;
+}
+
+export function setRuntimeMode_init_schema() {
+  RuntimeMode = RuntimeModeTag.INIT_SCHEMA;
+}
+
+export function setRuntimeMode_migration() {
+  RuntimeMode = RuntimeModeTag.RUN_MIGRATION;
+}
+
+export function setRuntimeMode_undo_migration() {
+  RuntimeMode = RuntimeModeTag.UNDO_MIGRATION;
+}
+
+export function setRuntimeMode_generate_migration() {
+  RuntimeMode = RuntimeModeTag.GENERATE_MIGRATION;
+}
+
+export function isRuntimeMode_dev(): boolean {
+  return RuntimeMode === RuntimeModeTag.DEV;
+}
+
+export function isRuntimeMode_prod(): boolean {
+  return RuntimeMode === RuntimeModeTag.PROD;
+}
+
+export function isRuntimeMode_init_schema(): boolean {
+  return RuntimeMode === RuntimeModeTag.INIT_SCHEMA;
+}
+
+export function isRuntimeMode_migration(): boolean {
+  return RuntimeMode === RuntimeModeTag.RUN_MIGRATION;
+}
+
+export function isRuntimeMode_generate_migration(): boolean {
+  return RuntimeMode === RuntimeModeTag.GENERATE_MIGRATION;
+}
+
+export function isRuntimeMode_undo_migration(): boolean {
+  return RuntimeMode === RuntimeModeTag.UNDO_MIGRATION;
+}

package/src/runtime/interpreter.ts

@@ -1579,6 +1579,7 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
             const res: Array<Instance> = new Array<Instance>();
             for (let i = 0; i < lastRes.length; ++i) {
               await computeExprAttributes(lastRes[i], crud.body?.attributes, attrs, env);
+              env.attributes.set('__patch', attrs);
               await runPreUpdateEvents(lastRes[i], env);
               maybeSetMetaAttributes(attrs, env, true);
               const finalInst: Instance = await resolver.updateInstance(lastRes[i], attrs);
@@ -2372,9 +2373,23 @@ export async function callPostEventOnSubscription(
   inst: Instance,
   env?: Environment
 ): Promise<any> {
+  const localEnv = env === undefined;
   const newEnv = env ? env : new Environment('onSubs.env');
-  await runPrePostEvents(crudType, false, inst, newEnv);
-  return newEnv.getLastResult();
+  try {
+    await runPrePostEvents(crudType, false, inst, newEnv);
+    if (localEnv) {
+      await newEnv.commitAllTransactions();
+    }
+    return newEnv.getLastResult();
+  } catch (reason: any) {
+    if (localEnv) {
+      await newEnv.rollbackAllTransactions();
+      logger.error(
+        `callPostEventOnSubscription failed for ${crudType} ${inst.getFqName()} - ${reason}`
+      );
+    }
+  }
+  return undefined;
 }
 
 async function runPrePostEvents(

package/src/runtime/loader.ts

@@ -191,6 +191,12 @@ export const DefaultAppSpec: ApplicationSpec = {
   version: '0.0.1',
 };
 
+let CurrentAppSpec: ApplicationSpec = DefaultAppSpec;
+
+export function getAppSpec(): ApplicationSpec {
+  return CurrentAppSpec;
+}
+
 async function getAllModules(
   dir: string,
   fs: ExtendedFileSystem,
@@ -234,6 +240,7 @@ async function loadApp(appDir: string, fsOptions?: any, callback?: Function): Pr
   const appJsonFile = `${appDir}${path.sep}package.json`;
   const s: string = await fs.readFile(appJsonFile);
   const appSpec: ApplicationSpec = JSON.parse(s);
+  CurrentAppSpec = appSpec;
   if (dependenciesCallback !== undefined && appSpec.dependencies) {
     const aldeps = new Array<DependencyInfo>();
     for (const [k, v] of Object.entries(appSpec.dependencies)) {

package/src/runtime/module.ts

@@ -399,6 +399,15 @@ export class Record extends ModuleEntry {
     this.compositeUqAttributes = findUqCompositeAttributes(scm);
   }
 
+  protected addMetaAttributes(): Record {
+    this.schema
+      .set(SysAttr_Created, SysAttr_CreatedSpec)
+      .set(SysAttr_CreatedBy, SysAttr_CreatedBySpec)
+      .set(SysAttr_LastModified, SysAttr_LastModifiedSpec)
+      .set(SysAttr_LastModifiedBy, SysAttr_LastModifiedBySpec);
+    return this;
+  }
+
   private addOneOfRefAttribute(s: string): Record {
     if (this.oneOfRefAttributes === undefined) {
       this.oneOfRefAttributes = [];
@@ -1152,15 +1161,6 @@ export class Entity extends Record {
     this.addMetaAttributes();
   }
 
-  private addMetaAttributes(): Entity {
-    this.schema
-      .set(SysAttr_Created, SysAttr_CreatedSpec)
-      .set(SysAttr_CreatedBy, SysAttr_CreatedBySpec)
-      .set(SysAttr_LastModified, SysAttr_LastModifiedSpec)
-      .set(SysAttr_LastModifiedBy, SysAttr_LastModifiedBySpec);
-    return this;
-  }
-
   setRbacSpecifications(rbac: RbacSpecification[]): Entity {
     this.rbac = rbac;
     return this;
@@ -1254,7 +1254,10 @@ export class Relationship extends Record {
     props?: Map<string, any>
   ) {
     super(name, moduleName, scm);
-    if (typ == 'between') this.relType = RelType.BETWEEN;
+    if (typ == 'between') {
+      this.relType = RelType.BETWEEN;
+      this.addMetaAttributes();
+    }
     this.node1 = node1;
     this.node2 = node2;
     this.properties = props;
@@ -3261,7 +3264,7 @@ function checkOneOfValue(attrSpec: AttributeSpec, attrName: string, attrValue: a
   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;
   }

package/src/runtime/modules/core.ts

@@ -1,7 +1,13 @@
 import { default as ai } from './ai.js';
 import { default as auth } from './auth.js';
 import { default as files } from './files.js';
-import { DefaultModuleName, DefaultModules, escapeSpecialChars, isString } from '../util.js';
+import {
+  DefaultModuleName,
+  DefaultModules,
+  escapeSpecialChars,
+  isString,
+  restoreSpecialChars,
+} from '../util.js';
 import { Instance, isInstanceOfType, makeInstance, newInstanceAttributes } from '../module.js';
 import {
   Environment,
@@ -120,6 +126,12 @@ event validateModule extends ValidationRequest {
 workflow validateModule {
   await Core.validateModule(validateModule.data)
 }
+
+entity Migration {
+  appVersion String @id,
+  ups String @optional,
+  downs String @optional
+}
 `;
 
 export const CoreModules: string[] = [];
@@ -404,3 +416,86 @@ export async function validateModule(moduleDef: any): Promise<Instance> {
     );
   }
 }
+
+const SqlSep = ';\n\n';
+
+export async function saveMigration(
+  version: string,
+  ups: string[] | undefined,
+  downs: string[] | undefined
+): Promise<boolean> {
+  try {
+    const env = new Environment(`migrations-${version}-env`);
+    await parseAndEvaluateStatement(
+      `purge {agentlang/Migration {appVersion? "${version}"}}`,
+      undefined,
+      env
+    );
+    let ups_str = '';
+    if (ups) {
+      ups_str = escapeSpecialChars(
+        ups
+          .map((s: string) => {
+            return s.trim();
+          })
+          .join(SqlSep)
+      );
+    }
+    let downs_str = '';
+    if (downs) {
+      downs_str = escapeSpecialChars(
+        downs
+          .map((s: string) => {
+            return s.trim();
+          })
+          .join(SqlSep)
+      );
+    }
+    const inst: Instance = await parseAndEvaluateStatement(`{agentlang/Migration {
+        appVersion "${version}",
+        ups "${ups_str}",
+        downs "${downs_str}"}}`);
+    if (isInstanceOfType(inst, 'agentlang/Migration') && inst.lookup('appVersion') === version) {
+      await env.commitAllTransactions();
+      return true;
+    } else {
+      logger.warn(`Failed to save migration for version ${version}`);
+    }
+  } catch (reason: any) {
+    logger.error(`Failed to save migration for version ${version} - ${reason}`);
+  }
+  return false;
+}
+
+export async function loadMigration(version: string): Promise<Instance | undefined> {
+  try {
+    const env = new Environment(`migrations-${version}-env`);
+    const insts: Instance[] = await parseAndEvaluateStatement(
+      `{agentlang/Migration {appVersion? "${version}"}}`,
+      undefined,
+      env
+    );
+    if (insts && insts.length > 0) {
+      return insts[0];
+    }
+  } catch (reason: any) {
+    logger.error(`Failed to lookup migration for version ${version} - ${reason}`);
+  }
+  return undefined;
+}
+
+export function migrationUps(inst: Instance): string[] | undefined {
+  const ups: string | undefined = inst.lookup('ups');
+  if (ups) {
+    return restoreSpecialChars(ups).split(SqlSep);
+  }
+  return undefined;
+}
+
+export function migrationDowns(inst: Instance): string[] | undefined {
+  const downs: string | undefined = inst.lookup('downs');
+  if (downs) {
+    return restoreSpecialChars(downs).split(SqlSep);
+  }
+  return undefined;
+}

package/src/runtime/resolvers/interface.ts

@@ -329,6 +329,8 @@ export class GenericResolver extends Resolver {
   }
 
   override async subscribe() {
+    const MaxErrors = 3;
+    let errCount = 0;
     while (true) {
       try {
         if (this.subs?.subscribe) {
@@ -338,6 +340,11 @@ export class GenericResolver extends Resolver {
         return;
       } catch (reason: any) {
         logger.warn(`subscribe error in resolver ${this.name}: ${reason}`);
+        if (errCount >= MaxErrors) {
+          logger.warn(`exiting resolver subscription after ${errCount} retries`);
+          break;
+        }
+        ++errCount;
       }
     }
   }

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

@@ -29,9 +29,16 @@ import { isString } from '../../util.js';
 import {
   DeletedFlagAttributeName,
   ForceReadPermFlag,
+  isRuntimeMode_dev,
+  isRuntimeMode_generate_migration,
+  isRuntimeMode_init_schema,
+  isRuntimeMode_migration,
+  isRuntimeMode_undo_migration,
   PathAttributeName,
   UnauthorisedError,
 } from '../../defs.js';
+import { saveMigration } from '../../modules/core.js';
+import { getAppSpec } from '../../loader.js';
 
 export let defaultDataSource: DataSource | undefined;
 
@@ -165,9 +172,10 @@ function mkDbName(): string {
 
 function makePostgresDataSource(
   entities: EntitySchema[],
-  config: DatabaseConfig | undefined,
-  synchronize: boolean = true
+  config: DatabaseConfig | undefined
 ): DataSource {
+  const synchronize = isRuntimeMode_dev() || isRuntimeMode_init_schema();
+  //const runMigrations = isRuntimeMode_migration() || isRuntimeMode_undo_migration() || !synchronize;
   return new DataSource({
     type: 'postgres',
     host: process.env.POSTGRES_HOST || config?.host || 'localhost',
@@ -176,6 +184,8 @@ function makePostgresDataSource(
     password: process.env.POSTGRES_PASSWORD || config?.password || 'postgres',
     database: process.env.POSTGRES_DB || config?.dbname || 'postgres',
     synchronize: synchronize,
+    migrationsRun: false,
+    dropSchema: false,
     entities: entities,
     invalidWhereValuesBehavior: {
       null: 'sql-null',
@@ -195,14 +205,17 @@ function getPostgressEnvPort(): number | undefined {
 
 function makeSqliteDataSource(
   entities: EntitySchema[],
-  config: DatabaseConfig | undefined,
-  synchronize: boolean = true
+  config: DatabaseConfig | undefined
 ): DataSource {
+  const synchronize = isRuntimeMode_dev() || isRuntimeMode_init_schema();
+  //const runMigrations = isRuntimeMode_migration() || isRuntimeMode_undo_migration() || !synchronize;
   return new DataSource({
     type: 'sqlite',
     database: config?.dbname || mkDbName(),
     synchronize: synchronize,
     entities: entities,
+    migrationsRun: false,
+    dropSchema: false,
     invalidWhereValuesBehavior: {
       null: 'sql-null',
       undefined: 'ignore',
@@ -210,6 +223,47 @@ function makeSqliteDataSource(
   });
 }
 
+async function execMigrationSql(dataSource: DataSource, sql: string[]) {
+  const queryRunner = dataSource.createQueryRunner();
+  await queryRunner.startTransaction();
+  for (let i = 0; i < sql.length; ++i) {
+    await queryRunner.query(sql[i]);
+  }
+  await queryRunner.commitTransaction();
+}
+
+async function maybeHandleMigrations(dataSource: DataSource) {
+  const is_migration = isRuntimeMode_migration();
+  const is_undo_migration = isRuntimeMode_undo_migration();
+  const is_gen_migration = isRuntimeMode_generate_migration();
+  if (is_migration || is_undo_migration || is_gen_migration) {
+    const sqlInMemory = await dataSource.driver.createSchemaBuilder().log();
+    let ups: string[] | undefined;
+    if (is_migration || is_gen_migration) {
+      ups = new Array<string>();
+      sqlInMemory.upQueries.forEach(upQuery => {
+        ups?.push(upQuery.query.replaceAll('`', '\\`'));
+      });
+    }
+    let downs: string[] | undefined;
+    if (is_undo_migration || is_gen_migration) {
+      downs = new Array<string>();
+      sqlInMemory.downQueries.forEach(downQuery => {
+        downs?.push(downQuery.query.replaceAll('`', '\\`'));
+      });
+    }
+    if (is_migration && ups?.length) {
+      await saveMigration(getAppSpec().version, ups, downs);
+      await execMigrationSql(dataSource, ups);
+    } else if (is_undo_migration && downs?.length) {
+      await saveMigration(getAppSpec().version, ups, downs);
+      await execMigrationSql(dataSource, downs);
+    } else if (is_gen_migration) {
+      await saveMigration(getAppSpec().version, ups, downs);
+    }
+  }
+}
+
 function isBrowser(): boolean {
   // window for DOM pages, self+importScripts for web workers
   return (
@@ -305,6 +359,7 @@ export async function initDatabase(config: DatabaseConfig | undefined) {
       const ormScm = modulesAsOrmSchema();
       defaultDataSource = mkds(ormScm.entities, config) as DataSource;
       await defaultDataSource.initialize();
+      await maybeHandleMigrations(defaultDataSource);
       if (ormScm.fkSpecs.length > 0) {
         const qr = defaultDataSource.createQueryRunner();
         for (let i = 0; i < ormScm.fkSpecs.length; ++i) {
@@ -316,7 +371,11 @@ export async function initDatabase(config: DatabaseConfig | undefined) {
             onDelete: fk.onDelete,
             onUpdate: fk.onUpdate,
           });
-          await qr.createForeignKey(asTableReference(fk.moduleName, fk.entityName), fkobj);
+          try {
+            await qr.createForeignKey(asTableReference(fk.moduleName, fk.entityName), fkobj);
+          } catch (reason: any) {
+            logger.warn(`initDatabase: ${reason}`);
+          }
         }
       }
       const vectEnts = ormScm.vectorEntities.map((es: EntitySchema) => {