@auto-engineer/narrative 1.12.0 → 1.12.1

package/package.json

@@ -27,9 +27,9 @@
     "typescript": "^5.9.2",
     "zod": "^3.22.4",
     "zod-to-json-schema": "^3.22.3",
-    "@auto-engineer/file-store": "1.12.0",
-    "@auto-engineer/id": "1.12.0",
-    "@auto-engineer/message-bus": "1.12.0"
+    "@auto-engineer/message-bus": "1.12.1",
+    "@auto-engineer/file-store": "1.12.1",
+    "@auto-engineer/id": "1.12.1"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
@@ -39,7 +39,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.12.0",
+  "version": "1.12.1",
   "scripts": {
     "build": "tsx scripts/build.ts",
     "test": "vitest run --reporter=dot",

package/src/transformers/model-to-narrative/ast/emit-helpers.specs.ts

@@ -0,0 +1,37 @@
+import ts from 'typescript';
+import { describe, expect, it } from 'vitest';
+import { type FieldTypeInfo, jsonToExpr } from './emit-helpers';
+
+function printNode(node: ts.Node): string {
+  const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+  const sourceFile = ts.createSourceFile('test.ts', '', ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
+  return printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
+}
+
+describe('jsonToExpr', () => {
+  it('should use typeResolver for array elements with type alias containing Date fields', () => {
+    const data = {
+      memberId: 'mem_001',
+      sessions: [{ savedAt: '2030-01-15T10:00:00.000Z', name: 'Morning workout' }],
+    };
+
+    const typeInfo: FieldTypeInfo = {
+      memberId: 'string',
+      sessions: 'Array<SessionData>',
+    };
+
+    const typeResolver = (typeName: string): FieldTypeInfo | undefined => {
+      if (typeName === 'SessionData') {
+        return { savedAt: 'Date', name: 'string' };
+      }
+      return undefined;
+    };
+
+    const result = jsonToExpr(ts, ts.factory, data, typeInfo, typeResolver);
+    const code = printNode(result);
+
+    expect(code).toEqual(
+      `{ memberId: "mem_001", sessions: [{ savedAt: new Date("2030-01-15T10:00:00.000Z"), name: "Morning workout" }] }`,
+    );
+  });
+});

package/src/transformers/model-to-narrative/ast/emit-helpers.ts

@@ -7,6 +7,8 @@ export interface FieldTypeInfo {
   [fieldName: string]: string; // field name -> type (e.g., 'Date', 'string', etc.)
 }
 
+export type TypeResolver = (typeName: string) => FieldTypeInfo | undefined;
+
 const ARRAY_TYPE_REGEX = /^Array<(.+)>$/;
 
 const VALID_IDENTIFIER_REGEX = /^[A-Za-z_]\w*$/;
@@ -70,13 +72,14 @@ function convertArrayField(
   f: tsNS.NodeFactory,
   arr: unknown[],
   fieldType: string,
+  typeResolver?: TypeResolver,
 ): tsNS.Expression {
   const elementType = parseArrayElementType(fieldType);
   if (elementType === 'Date') {
     return f.createArrayLiteralExpression(arr.map((elem) => convertDateValue(f, elem) ?? jsonToExpr(ts, f, elem)));
   }
-  const elementTypeInfo = elementType ? parseObjectTypeInfo(elementType) : undefined;
-  return f.createArrayLiteralExpression(arr.map((elem) => jsonToExpr(ts, f, elem, elementTypeInfo)));
+  const elementTypeInfo = elementType ? (parseObjectTypeInfo(elementType) ?? typeResolver?.(elementType)) : undefined;
+  return f.createArrayLiteralExpression(arr.map((elem) => jsonToExpr(ts, f, elem, elementTypeInfo, typeResolver)));
 }
 
 function convertObjectField(
@@ -84,9 +87,10 @@ function convertObjectField(
   f: tsNS.NodeFactory,
   obj: Record<string, unknown>,
   fieldType: string,
+  typeResolver?: TypeResolver,
 ): tsNS.Expression {
-  const nestedTypeInfo = parseObjectTypeInfo(fieldType);
-  return jsonToExpr(ts, f, obj, nestedTypeInfo);
+  const nestedTypeInfo = parseObjectTypeInfo(fieldType) ?? typeResolver?.(fieldType);
+  return jsonToExpr(ts, f, obj, nestedTypeInfo, typeResolver);
 }
 
 function computeFieldExpr(
@@ -95,16 +99,17 @@ function computeFieldExpr(
   x: unknown,
   fieldType: string | undefined,
   typeInfo: FieldTypeInfo | undefined,
+  typeResolver?: TypeResolver,
 ): tsNS.Expression {
   if (fieldType === 'Date') {
     const dateExpr = convertDateValue(f, x);
     if (dateExpr) return dateExpr;
   }
   if (fieldType && typeof x === 'object' && x !== null) {
-    if (Array.isArray(x)) return convertArrayField(ts, f, x, fieldType);
-    return convertObjectField(ts, f, x as Record<string, unknown>, fieldType);
+    if (Array.isArray(x)) return convertArrayField(ts, f, x, fieldType, typeResolver);
+    return convertObjectField(ts, f, x as Record<string, unknown>, fieldType, typeResolver);
   }
-  return jsonToExpr(ts, f, x, typeInfo);
+  return jsonToExpr(ts, f, x, typeInfo, typeResolver);
 }
 
 /**
@@ -115,6 +120,7 @@ export function jsonToExpr(
   f: tsNS.NodeFactory,
   v: unknown,
   typeInfo?: FieldTypeInfo,
+  typeResolver?: TypeResolver,
 ): tsNS.Expression {
   if (v === null) return f.createNull();
   switch (typeof v) {
@@ -132,14 +138,14 @@ export function jsonToExpr(
         return createDateNewExpr(f, v.toISOString());
       }
       if (Array.isArray(v)) {
-        return f.createArrayLiteralExpression(v.map((x) => jsonToExpr(ts, f, x, typeInfo)));
+        return f.createArrayLiteralExpression(v.map((x) => jsonToExpr(ts, f, x, typeInfo, typeResolver)));
       }
       const entries = Object.entries(v as Record<string, unknown>);
       return f.createObjectLiteralExpression(
         entries.map(([k, x]) =>
           f.createPropertyAssignment(
             VALID_IDENTIFIER_REGEX.test(k) ? f.createIdentifier(k) : f.createStringLiteral(k),
-            computeFieldExpr(ts, f, x, typeInfo?.[k], typeInfo),
+            computeFieldExpr(ts, f, x, typeInfo?.[k], typeInfo, typeResolver),
           ),
         ),
         false,

package/src/transformers/model-to-narrative/generators/gwt.ts

@@ -1,5 +1,5 @@
 import type tsNS from 'typescript';
-import { type FieldTypeInfo, jsonToExpr } from '../ast/emit-helpers';
+import { type FieldTypeInfo, jsonToExpr, type TypeResolver } from '../ast/emit-helpers';
 
 /**
  * Build a single specs() block for a GWT entry, adapting to slice type:
@@ -46,13 +46,14 @@ function chainGivenCalls(
     return base;
   }
 
+  const resolver = createTypeResolver(messages);
   const firstGiven = g.given[0];
   const firstTypeInfo = messages ? getFieldTypeInfo(messages, firstGiven.eventRef) : undefined;
 
   let result = f.createCallExpression(
     f.createPropertyAccessExpression(base, f.createIdentifier('given')),
     [f.createTypeReferenceNode(firstGiven.eventRef, undefined)],
-    [jsonToExpr(ts, f, firstGiven.exampleData, firstTypeInfo)],
+    [jsonToExpr(ts, f, firstGiven.exampleData, firstTypeInfo, resolver)],
   );
 
   for (let i = 1; i < g.given.length; i++) {
@@ -61,7 +62,7 @@ function chainGivenCalls(
     result = f.createCallExpression(
       f.createPropertyAccessExpression(result, f.createIdentifier('and')),
       [f.createTypeReferenceNode(givenEvent.eventRef, undefined)],
-      [jsonToExpr(ts, f, givenEvent.exampleData, typeInfo)],
+      [jsonToExpr(ts, f, givenEvent.exampleData, typeInfo, resolver)],
     );
   }
 
@@ -109,10 +110,11 @@ function chainWhenCall(
   }
 
   const typeInfo = messages !== undefined ? getFieldTypeInfo(messages, typeRef) : undefined;
+  const resolver = createTypeResolver(messages);
   return f.createCallExpression(
     f.createPropertyAccessExpression(base, f.createIdentifier('when')),
     typeRef !== '' ? [f.createTypeReferenceNode(typeRef, undefined)] : undefined,
-    [jsonToExpr(ts, f, exampleData, typeInfo)],
+    [jsonToExpr(ts, f, exampleData, typeInfo, resolver)],
   );
 }
 
@@ -129,7 +131,8 @@ function chainThenCall(
   const firstThenItem = g.then[0];
   const thenTypeRef = getThenTypeRef(firstThenItem);
   const typeInfo = messages && thenTypeRef ? getFieldTypeInfo(messages, thenTypeRef) : undefined;
-  const thenArg = buildThenItem(ts, f, firstThenItem, typeInfo);
+  const resolver = createTypeResolver(messages);
+  const thenArg = buildThenItem(ts, f, firstThenItem, typeInfo, resolver);
   const thenTypeParams = thenTypeRef ? [f.createTypeReferenceNode(thenTypeRef, undefined)] : undefined;
 
   return f.createCallExpression(f.createPropertyAccessExpression(base, f.createIdentifier('then')), thenTypeParams, [
@@ -142,22 +145,23 @@ function buildThenItem(
   f: tsNS.NodeFactory,
   t: GWTBlock['then'][0],
   typeInfo?: FieldTypeInfo,
+  typeResolver?: TypeResolver,
 ): tsNS.Expression {
   const item = t as Record<string, unknown>;
 
   if ('eventRef' in item) {
     const e = t as { eventRef: string; exampleData: Record<string, unknown> };
-    return jsonToExpr(ts, f, e.exampleData, typeInfo);
+    return jsonToExpr(ts, f, e.exampleData, typeInfo, typeResolver);
   }
 
   if ('commandRef' in item) {
     const c = t as { commandRef: string; exampleData: Record<string, unknown> };
-    return jsonToExpr(ts, f, c.exampleData, typeInfo);
+    return jsonToExpr(ts, f, c.exampleData, typeInfo, typeResolver);
   }
 
   if ('stateRef' in item) {
     const s = t as { stateRef: string; exampleData: Record<string, unknown> };
-    return jsonToExpr(ts, f, s.exampleData, typeInfo);
+    return jsonToExpr(ts, f, s.exampleData, typeInfo, typeResolver);
   }
 
   if ('errorType' in item) {
@@ -309,6 +313,16 @@ function getFieldTypeInfo(
   return typeInfo;
 }
 
+function createTypeResolver(
+  messages?: Array<{ type: string; name: string; fields: Array<{ name: string; type: string; required: boolean }> }>,
+): TypeResolver | undefined {
+  if (!messages) return undefined;
+  return (typeName: string) => {
+    const info = getFieldTypeInfo(messages, typeName);
+    return Object.keys(info).length > 0 ? info : undefined;
+  };
+}
+
 export function buildConsolidatedGwtSpecBlock(
   ts: typeof import('typescript'),
   f: tsNS.NodeFactory,