fix: call expr arguments definition (#97)

.changeset/nasty-rivers-hang.md

@@ -0,0 +1,7 @@
+---
+'@rekajs/parser': patch
+'@rekajs/types': patch
+'@rekajs/core': patch
+---
+
+Fix call expression arguments definition

packages/core/src/expression.ts

@@ -260,15 +260,9 @@ export const computeExpression = (
   if (expr instanceof t.CallExpression) {
     const fn = env.getByIdentifier(expr.identifier);
 
-    const params = Object.keys(expr.params).reduce(
-      (accum, key) => ({
-        ...accum,
-        [key]: computeExpression(expr.params[key], reka, env),
-      }),
-      {}
-    );
+    const args = expr.arguments.map((arg) => computeExpression(arg, reka, env));
 
-    return fn(params);
+    return fn(...args);
   }
 
   if (expr instanceof t.IfStatement) {

packages/core/src/resolver.ts

@@ -199,8 +199,8 @@ export class Resolver {
     if (expr instanceof t.CallExpression) {
       this.resolveExpr(expr.identifier, scope);
 
-      Object.keys(expr.params).forEach((param) => {
-        this.resolveExpr(expr.params[param], scope);
+      expr.arguments.forEach((arg) => {
+        this.resolveExpr(arg, scope);
       });
     }
 

packages/parser/src/parser.ts

@@ -143,23 +143,9 @@ const jsToReka = <T extends t.ASTNode = t.ASTNode>(
       case 'CallExpression': {
         const identifier = _convert(node.callee) as t.Identifier;
 
-        let params: Record<string, t.Expression> = {};
-
-        const arg0 = node.arguments[0];
-
-        if (arg0) {
-          const objExpr = _convert(arg0);
-          invariant(
-            objExpr instanceof t.ObjectExpression,
-            'Invalid options argument'
-          );
-
-          params = objExpr.properties;
-        }
-
         return t.callExpression({
           identifier,
-          params,
+          arguments: node.arguments.map((arg) => _convert(arg)),
         });
       }
       case 'IfStatement': {

packages/parser/src/stringifier.ts

@@ -130,28 +130,14 @@ class _Stringifier {
         this.stringify(node.identifier);
         this.writer.write('(');
 
-        const paramKeys = Object.keys(node.params);
-
-        if (paramKeys.length > 0) {
-          this.writer.write('{');
-        }
-
-        paramKeys.forEach((param, i, arr) => {
-          this.writer.write(
-            `${param}: ${this.writer.withTemp(() =>
-              this.stringify(node.params[param])
-            )}`
-          );
+        node.arguments.forEach((arg, i, arr) => {
+          this.stringify(arg);
 
           if (i !== arr.length - 1) {
             this.writer.write(', ');
           }
         });
 
-        if (paramKeys.length > 0) {
-          this.writer.write('}');
-        }
-
         this.writer.write(')');
       },
       ConditionalExpression: (node) => {

packages/types/src/generated/types.generated.ts

@@ -292,12 +292,12 @@ Schema.register('Func', Func);
 type CallExpressionParameters = {
   meta?: Record<string, any>;
   identifier: Identifier;
-  params?: Record<string, Expression>;
+  arguments?: Expression[];
 };
 
 export class CallExpression extends Expression {
   declare identifier: Identifier;
-  declare params: Record<string, Expression>;
+  declare arguments: Expression[];
   constructor(value: CallExpressionParameters) {
     super('CallExpression', value);
   }

packages/types/src/types.definition.ts

@@ -158,7 +158,7 @@ Schema.define('CallExpression', {
   extends: 'Expression',
   fields: (t) => ({
     identifier: t.node('Identifier'),
-    params: t.defaultValue(t.map(t.node('Expression')), {}),
+    arguments: t.defaultValue(t.array(t.node('Expression')), []),
   }),
 });