agentlang 0.10.5 → 0.10.7

package/src/runtime/modules/core.ts

@@ -702,10 +702,14 @@ export async function saveMigration(
           .join(SqlSep)
       );
     }
-    const inst: Instance = await parseAndEvaluateStatement(`{agentlang/Migration {
+    const inst: Instance = await parseAndEvaluateStatement(
+      `{agentlang/Migration {
         appVersion "${version}",
         ups "${ups_str}",
-        downs "${downs_str}"}}`);
+        downs "${downs_str}"}}`,
+      undefined,
+      env
+    );
     if (isInstanceOfType(inst, 'agentlang/Migration') && inst.lookup('appVersion') === version) {
       await env.commitAllTransactions();
       return true;

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

@@ -10,6 +10,7 @@ import {
 import { logger } from '../../logger.js';
 import {
   asTableReference,
+  ColumnRef,
   DefaultVectorDimension,
   modulesAsOrmSchema,
   OwnersSuffix,
@@ -32,10 +33,12 @@ import {
   DeletedFlagAttributeName,
   ForceReadPermFlag,
   getUserTenantId,
+  isRuntimeMode_apply_migration,
   isRuntimeMode_dev,
   isRuntimeMode_generate_migration,
   isRuntimeMode_init_schema,
   isRuntimeMode_migration,
+  isRuntimeMode_prod,
   isRuntimeMode_test,
   isRuntimeMode_undo_migration,
   PathAttributeName,
@@ -332,14 +335,80 @@ async function execMigrationSql(dataSource: DataSource, sql: string[]) {
   await queryRunner.commitTransaction();
 }
 
+export async function getSchemaDiff(dataSource: DataSource): Promise<string[]> {
+  const sqlInMemory = await dataSource.driver.createSchemaBuilder().log();
+  return sqlInMemory.upQueries.map((q: any) => q.query);
+}
+
+export type SimulateMigrationResult = {
+  success: boolean;
+  queries: string[];
+  errors: string[];
+};
+
+async function simulateMigrationPostgres(
+  dataSource: DataSource,
+  queries: string[]
+): Promise<SimulateMigrationResult> {
+  const queryRunner = dataSource.createQueryRunner();
+  const errors: string[] = [];
+  try {
+    await queryRunner.startTransaction();
+    for (const q of queries) {
+      await queryRunner.query(q);
+    }
+  } catch (err: any) {
+    errors.push(`Migration SQL failed: ${err.message}`);
+  } finally {
+    // Always rollback — this is a simulation
+    try {
+      await queryRunner.rollbackTransaction();
+    } catch {
+      // already rolled back or connection lost
+    }
+    await queryRunner.release();
+  }
+  return { success: errors.length === 0, queries, errors };
+}
+
+function simulateMigrationDryRun(queries: string[]): SimulateMigrationResult {
+  return { success: true, queries, errors: [] };
+}
+
+export async function simulateMigration(dataSource: DataSource): Promise<SimulateMigrationResult> {
+  const queries = await getSchemaDiff(dataSource);
+  if (queries.length === 0) {
+    return { success: true, queries: [], errors: [] };
+  }
+  if (dataSource.options.type === 'postgres') {
+    return simulateMigrationPostgres(dataSource, queries);
+  }
+  return simulateMigrationDryRun(queries);
+}
+
+async function validateSchemaInProd(dataSource: DataSource) {
+  if (!isRuntimeMode_prod()) return;
+  const pendingQueries = (await getSchemaDiff(dataSource)).filter(
+    q => !q.match(/DROP CONSTRAINT\s+"FK_/i)
+  );
+  if (pendingQueries.length > 0) {
+    const pending = pendingQueries.join('\n  ');
+    throw new Error(
+      `Schema mismatch detected: the app model does not match the database schema. ` +
+        `Run migrations before starting in production mode.\n  Pending changes:\n  ${pending}`
+    );
+  }
+}
+
 async function maybeHandleMigrations(dataSource: DataSource) {
   const is_migration = isRuntimeMode_migration();
+  const is_apply_migration = isRuntimeMode_apply_migration();
   const is_undo_migration = isRuntimeMode_undo_migration();
   const is_gen_migration = isRuntimeMode_generate_migration();
-  if (is_migration || is_undo_migration || is_gen_migration) {
+  if (is_migration || is_apply_migration || is_undo_migration || is_gen_migration) {
     const sqlInMemory = await dataSource.driver.createSchemaBuilder().log();
     let ups: string[] | undefined;
-    if (is_migration || is_gen_migration) {
+    if (is_migration || is_apply_migration || is_gen_migration) {
       ups = new Array<string>();
       sqlInMemory.upQueries.forEach(upQuery => {
         ups?.push(upQuery.query.replaceAll('`', '\\`'));
@@ -353,8 +422,37 @@ async function maybeHandleMigrations(dataSource: DataSource) {
       });
     }
     if (is_migration && ups?.length) {
+      // Review-only: display pending changes and simulation result, but do not apply
+      logger.info('Pending migration queries:');
+      ups.forEach((q, i) => {
+        logger.info(`  [${i + 1}] ${q}`);
+        console.log(q + ';');
+      });
+      const simulation = await simulateMigration(dataSource);
+      if (!simulation.success) {
+        logger.error(`Migration simulation failed:\n  ${simulation.errors.join('\n  ')}`);
+        throw new Error(
+          `Migration aborted: simulation failed.\n  ${simulation.errors.join('\n  ')}`
+        );
+      }
+      logger.info('Migration simulation passed.');
+      logger.info('Run `applyMigration` to apply these changes.');
+    } else if (is_migration && (!ups || ups.length === 0)) {
+      logger.info('No pending migration changes detected.');
+    } else if (is_apply_migration && ups?.length) {
+      const simulation = await simulateMigration(dataSource);
+      if (!simulation.success) {
+        logger.error(`Migration simulation failed:\n  ${simulation.errors.join('\n  ')}`);
+        throw new Error(
+          `Migration aborted: simulation failed.\n  ${simulation.errors.join('\n  ')}`
+        );
+      }
+      logger.info('Migration simulation passed, applying changes...');
       await saveMigration(getAppSpec().version, ups, downs);
       await execMigrationSql(dataSource, ups);
+      logger.info('Migration applied successfully.');
+    } else if (is_apply_migration && (!ups || ups.length === 0)) {
+      logger.info('No pending migration changes to apply.');
     } else if (is_undo_migration && downs?.length) {
       await saveMigration(getAppSpec().version, ups, downs);
       await execMigrationSql(dataSource, downs);
@@ -444,6 +542,15 @@ export function isUsingSqljs(): boolean {
   return getDbType(AppConfig?.store) == 'sqljs';
 }
 
+/** Resolved store DB type (uses the same cache as initDatabase). */
+export function getStoreDbType(config?: DatabaseConfig | undefined): string {
+  return getDbType(config);
+}
+
+export function isPostgresStore(): boolean {
+  return getDbType(AppConfig?.store) === 'postgres';
+}
+
 export async function isVectorStoreSupported(): Promise<boolean> {
   const dbType = getDbType(AppConfig?.store);
   if (dbType === 'postgres') return true;
@@ -458,7 +565,7 @@ export async function initDatabase(config: DatabaseConfig | undefined) {
   if (defaultDataSource === undefined) {
     const mkds = getDsFunction(config);
     if (mkds) {
-      const ormScm = modulesAsOrmSchema();
+      const ormScm = modulesAsOrmSchema(getStoreDbType(config));
       defaultDataSource = mkds(ormScm.entities, config) as DataSource;
       await defaultDataSource.initialize();
       await maybeHandleMigrations(defaultDataSource);
@@ -480,6 +587,7 @@ export async function initDatabase(config: DatabaseConfig | undefined) {
           }
         }
       }
+      await validateSchemaInProd(defaultDataSource);
       const vectEnts = ormScm.vectorEntities.map((es: EntitySchema) => {
         return es.options.name;
       });
@@ -991,6 +1099,12 @@ function objectToWhereClause(queryObj: object, queryVals: any, tableName?: strin
   Object.entries(queryObj).forEach((value: [string, any]) => {
     let op: string = value[1] as string;
     const k = value[0];
+    if (queryVals[k] instanceof ColumnRef) {
+      const colRef = (queryVals[k] as ColumnRef).toSql(tableName);
+      clauses.push(tableName ? `"${tableName}"."${k}" ${op} ${colRef}` : `"${k}" ${op} ${colRef}`);
+      delete queryVals[k];
+      return;
+    }
     const isnullcheck = queryVals[k] === null;
     if (isnullcheck) {
       if (op === '=') {
@@ -1018,6 +1132,11 @@ function objectToRawWhereClause(queryObj: object, queryVals: any, tableName?: st
   Object.entries(queryObj).forEach((value: [string, any]) => {
     let op: string = value[1] as string;
     const k: string = value[0];
+    if (queryVals[k] instanceof ColumnRef) {
+      const colRef = (queryVals[k] as ColumnRef).toSql(tableName);
+      clauses.push(tableName ? `"${tableName}"."${k}" ${op} ${colRef}` : `"${k}" ${op} ${colRef}`);
+      return;
+    }
     if (queryVals[k] === null) {
       if (op === '=') {
         op = 'IS';

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

@@ -72,6 +72,15 @@ export function asColumnReference(n: string, tableName: string, entityName: stri
   }
 }
 
+export class ColumnRef {
+  constructor(public readonly ref: string) {}
+  toSql(tableName?: string): string {
+    const dotIdx = this.ref.lastIndexOf('.');
+    const field = dotIdx >= 0 ? this.ref.substring(dotIdx + 1) : this.ref;
+    return tableName ? `"${tableName}"."${field}"` : `"${field}"`;
+  }
+}
+
 export function modulesAsDbSchema(): TableSchema[] {
   const result: TableSchema[] = new Array<TableSchema>();
   getModuleNames().forEach((n: string) => {
@@ -105,7 +114,7 @@ function isSqlDefault(d: any): boolean {
   return typeof d !== 'string' || !d.endsWith('()') || SqlDefaultFunctions.has(d);
 }
 
-export function modulesAsOrmSchema(): OrmSchema {
+export function modulesAsOrmSchema(storeDbType: string): OrmSchema {
   const ents: EntitySchema[] = [];
   const vects: EntitySchema[] = [];
   const fkSpecs: FkSpec[] = [];
@@ -115,12 +124,12 @@ export function modulesAsOrmSchema(): OrmSchema {
     const entities: Record[] = mod.getEntityEntries();
     const rels: Record[] = mod.getBetweenRelationshipEntriesThatNeedStore();
     entities.concat(rels).forEach((entry: Record) => {
-      ents.push(new EntitySchema<any>(ormSchemaFromRecordSchema(n, entry)));
+      ents.push(new EntitySchema<any>(ormSchemaFromRecordSchema(n, entry, storeDbType)));
       const ownerEntry = createOwnersEntity(entry);
-      ents.push(new EntitySchema<any>(ormSchemaFromRecordSchema(n, ownerEntry, true)));
+      ents.push(new EntitySchema<any>(ormSchemaFromRecordSchema(n, ownerEntry, storeDbType, true)));
       if (entry.getFullTextSearchAttributes()) {
         const vectorEntry = createVectorEntity(entry);
-        vects.push(new EntitySchema<any>(ormSchemaFromRecordSchema(n, vectorEntry, true)));
+        vects.push(new EntitySchema<any>(ormSchemaFromRecordSchema(n, vectorEntry, storeDbType, true)));
       }
     });
     entities.forEach((r: Record) => {
@@ -136,6 +145,7 @@ export function modulesAsOrmSchema(): OrmSchema {
 function ormSchemaFromRecordSchema(
   moduleName: string,
   entry: Record,
+  storeDbType: string,
   hasOwnPk?: boolean
 ): EntitySchemaOptions<any> {
   const entityName = entry.name;
@@ -159,13 +169,16 @@ function ormSchemaFromRecordSchema(
     else if (autoUuid) genStrat = 'uuid';
     const isuq: boolean = isUniqueAttribute(attrSpec);
     const ispk: boolean = chkforpk && isIdAttribute(attrSpec);
+    const isArr: boolean = isArrayAttribute(attrSpec);
+    const usePgArray: boolean = isArr && storeDbType === 'postgres';
     const colDef: EntitySchemaColumnOptions = {
-      type: asSqlType(attrSpec.type),
+      type: usePgArray ? asSqlType(attrSpec.type) : isArr ? 'varchar' : asSqlType(attrSpec.type),
       generated: genStrat,
       default: d,
       unique: isuq,
       primary: ispk,
       nullable: isOptionalAttribute(attrSpec),
+      ...(usePgArray ? { array: true } : {}),
     };
     if (ispk) {
       needPath = false;

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

@@ -9,8 +9,10 @@ import {
   getEntityRbacRules,
   Instance,
   InstanceAttributes,
+  isArrayAttribute,
   isBetweenRelationship,
   newInstanceAttributes,
+  type RecordSchema,
   Relationship,
 } from '../../module.js';
 import {
@@ -35,6 +37,7 @@ import {
   hardDeleteRow,
   insertBetweenRow,
   insertRow,
+  isPostgresStore,
   isVectorStoreSupported,
   JoinClause,
   JoinOn,
@@ -47,6 +50,22 @@ import {
   vectorStoreSearchEntryExists,
 } from './database.js';
 import { AggregateFunctionCall, Environment } from '../../interpreter.js';
+
+/** Postgres uses native array columns; other drivers store JSON text in varchar. */
+function rowObjectForSqlPersistence(row: object, schema: RecordSchema): object {
+  if (isPostgresStore()) {
+    return row;
+  }
+  const o = { ...(row as Record<string, any>) };
+  schema.forEach((spec, name) => {
+    if (!isArrayAttribute(spec)) return;
+    const v = o[name];
+    if (Array.isArray(v)) {
+      o[name] = JSON.stringify(v);
+    }
+  });
+  return o;
+}
 import {
   DeletedFlagAttributeName,
   ParentAttributeName,
@@ -230,7 +249,10 @@ export class SqlDbResolver extends Resolver {
       attrs.set(PathAttributeName, p);
     }
     const n: string = asTableReference(inst.moduleName, inst.name);
-    const rowObj: object = inst.attributesWithStringifiedObjects();
+    const rowObj: object = rowObjectForSqlPersistence(
+      inst.attributesWithStringifiedObjects(),
+      inst.record.schema
+    );
     await insertRow(n, rowObj, ctx, orUpdate);
     if (inst.record.getEmbeddingConfig() || inst.record.getFullTextSearchAttributes()) {
       const path = attrs.get(PathAttributeName);
@@ -292,7 +314,10 @@ export class SqlDbResolver extends Resolver {
     const queryVals: object = Object.fromEntries(
       new Map<string, any>().set(PathAttributeName, inst.attributes.get(PathAttributeName))
     );
-    const updateObj: object = Instance.stringifyObjects(newAttrs);
+    const updateObj: object = rowObjectForSqlPersistence(
+      Instance.stringifyObjects(newAttrs),
+      inst.record.schema
+    );
     await updateRow(
       asTableReference(inst.moduleName, inst.name),
       queryObj,

package/src/syntaxes/agentlang.monarch.ts

@@ -14,6 +14,7 @@ export default {
             { regex: /[_a-zA-Z][\w_]*/, action: { cases: { '@keywords': {"token":"keyword"}, '@default': {"token":"string"} }} },
             { regex: /"(\\(?:[\s\S])|(?:(?!(\\|"|\r|\n))[\s\S]*?)|\r?\n)*"/, action: {"token":"string"} },
             { regex: /`(\\(?:[\s\S])|(?:(?!(\\|`|\r|\n))[\s\S]*?)|\r?\n)*`/, action: {"token":"string"} },
+            { regex: /-?(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)/, action: {"token":"number"} },
             { regex: /-?[0-9]+/, action: {"token":"number"} },
             { include: '@whitespace' },
             { regex: /@symbols/, action: { cases: { '@operators': {"token":"operator"}, '@default': {"token":""} }} },