@mmapp/react-compiler 0.1.0-alpha.1

package/src/__tests__/server-action-extractor.test.ts

@@ -0,0 +1,128 @@
+/**
+ * Server Action Extractor Tests — validates *.server.ts function extraction.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { transformSync } from '@babel/core';
+import babelPlugin from '../babel';
+
+function compileServerAction(code: string, filename = 'actions.server.ts'): any {
+  const result = transformSync(code, {
+    filename,
+    plugins: [[babelPlugin]],
+    parserOpts: { plugins: ['typescript'], attachComment: true },
+  });
+  return (result as any)?.metadata?.mindmatrixIR;
+}
+
+describe('Server Action Extractor', () => {
+  it('should detect server action files by .server.ts extension', () => {
+    const ir = compileServerAction(`
+      export async function notifyMembers(ctx: TransitionContext) {
+        // action body
+      }
+    `);
+
+    expect(ir).toBeDefined();
+    expect(ir.metadata?.serverActions).toBeDefined();
+    expect(ir.metadata.serverActions).toHaveLength(1);
+  });
+
+  it('should extract function name and async flag', () => {
+    const ir = compileServerAction(`
+      export async function notifyMembers(ctx: TransitionContext) {}
+      export function logEvent(ctx: TransitionContext) {}
+    `);
+
+    const actions = ir.metadata.serverActions;
+    expect(actions).toHaveLength(2);
+    expect(actions[0].name).toBe('notifyMembers');
+    expect(actions[0].async).toBe(true);
+    expect(actions[1].name).toBe('logEvent');
+    expect(actions[1].async).toBe(false);
+  });
+
+  it('should extract parameter names', () => {
+    const ir = compileServerAction(`
+      export async function handler(ctx: TransitionContext) {}
+    `);
+
+    const action = ir.metadata.serverActions[0];
+    expect(action.params).toEqual(['ctx']);
+  });
+
+  it('should extract context type annotation', () => {
+    const ir = compileServerAction(`
+      export async function handler(ctx: TransitionContext) {}
+    `);
+
+    const action = ir.metadata.serverActions[0];
+    expect(action.contextType).toBe('TransitionContext');
+  });
+
+  it('should handle arrow function exports', () => {
+    const ir = compileServerAction(`
+      export const sendEmail = async (ctx: TransitionContext) => {
+        // send email
+      };
+    `);
+
+    const actions = ir.metadata.serverActions;
+    expect(actions).toHaveLength(1);
+    expect(actions[0].name).toBe('sendEmail');
+    expect(actions[0].async).toBe(true);
+  });
+
+  it('should not extract non-exported functions', () => {
+    const ir = compileServerAction(`
+      function privateHelper() {}
+      export async function publicHandler(ctx: TransitionContext) {}
+    `);
+
+    const actions = ir.metadata.serverActions;
+    expect(actions).toHaveLength(1);
+    expect(actions[0].name).toBe('publicHandler');
+  });
+
+  it('should not activate for non-server files', () => {
+    const ir = compileServerAction(`
+      export async function handler(ctx: TransitionContext) {}
+    `, 'regular.ts');
+
+    // For regular files, no serverActions in metadata
+    expect(ir.metadata?.serverActions).toBeUndefined();
+  });
+
+  it('should extract JSDoc description', () => {
+    const ir = compileServerAction(`
+      /**
+       * Notifies all channel members about a new message.
+       * @param ctx - The transition context
+       */
+      export async function notifyMembers(ctx: TransitionContext) {}
+    `);
+
+    const action = ir.metadata.serverActions[0];
+    expect(action.description).toBe('Notifies all channel members about a new message.');
+  });
+
+  it('should handle multiple parameters', () => {
+    const ir = compileServerAction(`
+      export function handler(ctx: TransitionContext) {}
+    `);
+
+    const action = ir.metadata.serverActions[0];
+    expect(action.params).toEqual(['ctx']);
+  });
+
+  it('should handle function expression exports', () => {
+    const ir = compileServerAction(`
+      export const handler = function(ctx: TransitionContext) {};
+    `);
+
+    const actions = ir.metadata.serverActions;
+    expect(actions).toHaveLength(1);
+    expect(actions[0].name).toBe('handler');
+    expect(actions[0].async).toBe(false);
+  });
+});

package/src/__tests__/smart-type-inference.test.ts

@@ -0,0 +1,365 @@
+/**
+ * Smart Type Inference Tests — validates enhanced useState type inference.
+ *
+ * Tests the compiler's ability to infer field types from:
+ * - TypeScript generic type parameters (useState<string[]>)
+ * - Union types with null/undefined (useState<{ name: string } | null>)
+ * - Array<T> generic reference syntax
+ * - Default value fallback when no type annotation present
+ */
+
+import { describe, it, expect } from 'vitest';
+import { transformSync } from '@babel/core';
+import babelPlugin from '../babel';
+
+function compileWorkflow(code: string) {
+  const result = transformSync(code, {
+    filename: 'test.workflow.tsx',
+    plugins: [[babelPlugin, { mode: 'infer' }]],
+    parserOpts: { plugins: ['jsx', 'typescript'] },
+  });
+
+  return (result as any)?.metadata?.mindmatrixIR;
+}
+
+describe('Smart Type Inference — TypeScript annotations', () => {
+  it('should infer multi_select from string[] annotation', () => {
+    const ir = compileWorkflow(`
+      export function TestWorkflow() {
+        const [tags, setTags] = useState<string[]>([]);
+        return <div>{tags}</div>;
+      }
+    `);
+
+    expect(ir.fields).toHaveLength(1);
+    expect(ir.fields[0]).toMatchObject({
+      name: 'tags',
+      type: 'multi_select',
+    });
+  });
+
+  it('should infer multi_select from Array<string> annotation', () => {
+    const ir = compileWorkflow(`
+      export function TestWorkflow() {
+        const [items, setItems] = useState<Array<string>>([]);
+        return <div>{items}</div>;
+      }
+    `);
+
+    expect(ir.fields).toHaveLength(1);
+    expect(ir.fields[0]).toMatchObject({
+      name: 'items',
+      type: 'multi_select',
+    });
+  });
+
+  it('should infer json from object type literal annotation', () => {
+    const ir = compileWorkflow(`
+      export function TestWorkflow() {
+        const [config, setConfig] = useState<{ theme: string; fontSize: number }>({ theme: 'dark', fontSize: 14 });
+        return <div>{config.theme}</div>;
+      }
+    `);
+
+    expect(ir.fields).toHaveLength(1);
+    expect(ir.fields[0]).toMatchObject({
+      name: 'config',
+      type: 'json',
+    });
+  });
+
+  it('should infer json from Record<K, V> annotation', () => {
+    const ir = compileWorkflow(`
+      export function TestWorkflow() {
+        const [metadata, setMetadata] = useState<Record<string, unknown>>({});
+        return <div />;
+      }
+    `);
+
+    expect(ir.fields).toHaveLength(1);
+    expect(ir.fields[0]).toMatchObject({
+      name: 'metadata',
+      type: 'json',
+    });
+  });
+
+  it('should infer date from Date annotation', () => {
+    const ir = compileWorkflow(`
+      export function TestWorkflow() {
+        const [createdAt, setCreatedAt] = useState<Date>(new Date());
+        return <div />;
+      }
+    `);
+
+    expect(ir.fields).toHaveLength(1);
+    expect(ir.fields[0]).toMatchObject({
+      name: 'createdAt',
+      type: 'date',
+    });
+  });
+
+  it('should infer url from URL annotation', () => {
+    const ir = compileWorkflow(`
+      export function TestWorkflow() {
+        const [link, setLink] = useState<URL>(null);
+        return <div />;
+      }
+    `);
+
+    expect(ir.fields).toHaveLength(1);
+    expect(ir.fields[0]).toMatchObject({
+      name: 'link',
+      type: 'url',
+    });
+  });
+});
+
+describe('Smart Type Inference — nullable unions', () => {
+  it('should infer json from object | null annotation', () => {
+    const ir = compileWorkflow(`
+      export function TestWorkflow() {
+        const [user, setUser] = useState<{ name: string; age: number } | null>(null);
+        return <div />;
+      }
+    `);
+
+    expect(ir.fields).toHaveLength(1);
+    expect(ir.fields[0]).toMatchObject({
+      name: 'user',
+      type: 'json',
+      default_value: null,
+    });
+  });
+
+  it('should infer text from string | null annotation', () => {
+    const ir = compileWorkflow(`
+      export function TestWorkflow() {
+        const [label, setLabel] = useState<string | null>(null);
+        return <div />;
+      }
+    `);
+
+    expect(ir.fields).toHaveLength(1);
+    expect(ir.fields[0]).toMatchObject({
+      name: 'label',
+      type: 'text',
+      default_value: null,
+    });
+  });
+
+  it('should infer number from number | undefined annotation', () => {
+    const ir = compileWorkflow(`
+      export function TestWorkflow() {
+        const [score, setScore] = useState<number | undefined>(undefined);
+        return <div />;
+      }
+    `);
+
+    expect(ir.fields).toHaveLength(1);
+    expect(ir.fields[0]).toMatchObject({
+      name: 'score',
+      type: 'number',
+    });
+  });
+
+  it('should infer multi_select from string[] | null annotation', () => {
+    const ir = compileWorkflow(`
+      export function TestWorkflow() {
+        const [tags, setTags] = useState<string[] | null>(null);
+        return <div />;
+      }
+    `);
+
+    expect(ir.fields).toHaveLength(1);
+    expect(ir.fields[0]).toMatchObject({
+      name: 'tags',
+      type: 'multi_select',
+      default_value: null,
+    });
+  });
+
+  it('should infer select from string literal union with null', () => {
+    const ir = compileWorkflow(`
+      export function TestWorkflow() {
+        const [status, setStatus] = useState<'draft' | 'published' | null>(null);
+        return <div />;
+      }
+    `);
+
+    expect(ir.fields).toHaveLength(1);
+    expect(ir.fields[0]).toMatchObject({
+      name: 'status',
+      type: 'select',
+    });
+    expect((ir.fields[0] as any).validation?.options).toEqual(['draft', 'published']);
+  });
+
+  it('should infer custom type slug from CustomType | null annotation', () => {
+    const ir = compileWorkflow(`
+      export function TestWorkflow() {
+        const [address, setAddress] = useState<HomeAddress | null>(null);
+        return <div />;
+      }
+    `);
+
+    expect(ir.fields).toHaveLength(1);
+    expect(ir.fields[0]).toMatchObject({
+      name: 'address',
+      type: 'home-address',
+      default_value: null,
+    });
+  });
+
+  it('should infer json from multiple non-null union members', () => {
+    const ir = compileWorkflow(`
+      export function TestWorkflow() {
+        const [value, setValue] = useState<string | number>(0);
+        return <div />;
+      }
+    `);
+
+    expect(ir.fields).toHaveLength(1);
+    expect(ir.fields[0]).toMatchObject({
+      name: 'value',
+      type: 'json',
+    });
+  });
+});
+
+describe('Smart Type Inference — default value fallback', () => {
+  it('should infer number from numeric default', () => {
+    const ir = compileWorkflow(`
+      export function TestWorkflow() {
+        const [count, setCount] = useState(42);
+        return <div>{count}</div>;
+      }
+    `);
+
+    expect(ir.fields[0]).toMatchObject({
+      name: 'count',
+      type: 'number',
+      default_value: 42,
+    });
+  });
+
+  it('should infer text from string default', () => {
+    const ir = compileWorkflow(`
+      export function TestWorkflow() {
+        const [label, setLabel] = useState('hello');
+        return <div>{label}</div>;
+      }
+    `);
+
+    expect(ir.fields[0]).toMatchObject({
+      name: 'label',
+      type: 'text',
+      default_value: 'hello',
+    });
+  });
+
+  it('should infer boolean from boolean default', () => {
+    const ir = compileWorkflow(`
+      export function TestWorkflow() {
+        const [active, setActive] = useState(true);
+        return <div />;
+      }
+    `);
+
+    expect(ir.fields[0]).toMatchObject({
+      name: 'active',
+      type: 'boolean',
+      default_value: true,
+    });
+  });
+
+  it('should infer json from array default', () => {
+    const ir = compileWorkflow(`
+      export function TestWorkflow() {
+        const [items, setItems] = useState([1, 2, 3]);
+        return <div />;
+      }
+    `);
+
+    expect(ir.fields[0]).toMatchObject({
+      name: 'items',
+      type: 'json',
+      default_value: [1, 2, 3],
+    });
+  });
+
+  it('should infer json from object default', () => {
+    const ir = compileWorkflow(`
+      export function TestWorkflow() {
+        const [config, setConfig] = useState({ key: 'value' });
+        return <div />;
+      }
+    `);
+
+    expect(ir.fields[0]).toMatchObject({
+      name: 'config',
+      type: 'json',
+    });
+  });
+
+  it('should infer date from new Date() default', () => {
+    const ir = compileWorkflow(`
+      export function TestWorkflow() {
+        const [createdAt, setCreatedAt] = useState(new Date());
+        return <div />;
+      }
+    `);
+
+    expect(ir.fields[0]).toMatchObject({
+      name: 'createdAt',
+      type: 'date',
+    });
+  });
+
+  it('should default to text when no annotation or meaningful default', () => {
+    const ir = compileWorkflow(`
+      export function TestWorkflow() {
+        const [unknown, setUnknown] = useState(null);
+        return <div />;
+      }
+    `);
+
+    expect(ir.fields[0]).toMatchObject({
+      name: 'unknown',
+      type: 'text',
+      default_value: null,
+    });
+  });
+});
+
+describe('Smart Type Inference — annotation takes priority over default', () => {
+  it('should use annotation type even when default suggests different type', () => {
+    const ir = compileWorkflow(`
+      export function TestWorkflow() {
+        const [data, setData] = useState<string[]>([]);
+        return <div />;
+      }
+    `);
+
+    // Annotation says string[] → multi_select, even though default [] would give json
+    expect(ir.fields[0]).toMatchObject({
+      name: 'data',
+      type: 'multi_select',
+      default_value: [],
+    });
+  });
+
+  it('should use custom type slug from annotation even with null default', () => {
+    const ir = compileWorkflow(`
+      export function TestWorkflow() {
+        const [email, setEmail] = useState<Email>(null);
+        return <div />;
+      }
+    `);
+
+    expect(ir.fields[0]).toMatchObject({
+      name: 'email',
+      type: 'email',
+      default_value: null,
+    });
+  });
+});