Compiler: allow function calls on lazy state

integration-tests/execute/ava.config.js

@@ -0,0 +1,13 @@
+export default {
+  extensions: {
+    ts: 'module',
+  },
+
+  environmentVariables: {
+    TS_NODE_TRANSPILE_ONLY: 'true',
+  },
+
+  nodeArguments: ['--loader=ts-node/esm', '--no-warnings', '--experimental-vm-modules'],
+
+  files: ['test/**/*test.ts'],
+};

integration-tests/execute/test/lazy-state.test.ts

@@ -0,0 +1,51 @@
+import test from 'ava';
+import execute from '../src/execute';
+
+test.serial(
+  'use lazy-state in template literal & property access',
+  async (t) => {
+    const state = {
+      keyName: 'someKey',
+      firstName: 'John',
+      lastName: 'Doe',
+    };
+    const job = `
+fnIf(\`$\{$.keyName\}\` === 'someKey', state => {
+  state.literal = true;
+  return state;
+})
+
+fnIf($.firstName + $['lastName'] === 'JohnDoe', state=> {
+  state.concat = true;
+  return state;
+})`;
+
+    const result = await execute(job, state);
+    t.is(result.literal, true);
+    t.is(result.concat, true);
+  }
+);
+
+test.serial('state function called with lazy-state', async (t) => {
+  const state = { data: {} };
+
+  const job = `
+fn((state) => {
+    state.callMeMaybe = (value) => {
+        state.data.greetings = "Hello " + value
+		return state;
+    }
+    return state
+});
+
+fn(state => {
+    state.data.name = "John"
+    return state;
+})
+
+fn($.callMeMaybe($.data.name))`;
+
+  const result = await execute(job, state);
+
+  t.deepEqual(result, { data: { name: 'John', greetings: 'Hello John' } });
+});

packages/compiler/src/transforms/lazy-state.ts

@@ -29,7 +29,15 @@ const ensureParentArrow = (path: NodePath<n.MemberExpression>) => {
   }
 
   if (root && n.CallExpression.check(root.node)) {
-    const arg = last as NodePath;
+    let arg = last as NodePath;
+    if (
+      arg.parentPath &&
+      n.CallExpression.check(arg.parentPath.node) &&
+      n.MemberExpression.check(arg.parentPath.node.callee) &&
+      arg.parentPath.node.callee.object.name === 'state'
+    ) {
+      arg = arg.parentPath;
+    }
 
     if (!isOpenFunction(arg)) {
       const params = b.identifier('state');

packages/compiler/test/transforms/lazy-state.test.ts

@@ -219,3 +219,21 @@ test('convert logical not', (t) => {
 
   t.is(code, 'get(state => !state.data.x)');
 });
+
+test('convert function call on state', (t) => {
+  const ast = parse('fn($.callMeMaybe())');
+
+  const transformed = transform(ast, [visitors]);
+  const { code } = print(transformed);
+
+  t.is(code, 'fn(state => state.callMeMaybe())');
+});
+
+test('convert function call on state with state argument', (t) => {
+  const ast = parse('fn($.callMeMaybe($.age))');
+
+  const transformed = transform(ast, [visitors]);
+  const { code } = print(transformed);
+
+  t.is(code, 'fn(state => state.callMeMaybe(state.age))');
+});