@travetto/schema 6.0.1 → 7.0.0-rc.0

package/support/transformer/util.ts

@@ -4,10 +4,14 @@ import {
   DecoratorUtil, DocUtil, ParamDocumentation, TransformerState, transformCast,
 } from '@travetto/transformer';
 
+export type ComputeConfig = { type?: AnyType, root?: ts.Node, name?: string, index?: number };
+
 export class SchemaTransformUtil {
 
   static SCHEMA_IMPORT = '@travetto/schema/src/decorator/schema.ts';
+  static METHOD_IMPORT = '@travetto/schema/src/decorator/method.ts';
   static FIELD_IMPORT = '@travetto/schema/src/decorator/field.ts';
+  static INPUT_IMPORT = '@travetto/schema/src/decorator/input.ts';
   static COMMON_IMPORT = '@travetto/schema/src/decorator/common.ts';
   static TYPES_IMPORT = '@travetto/schema/src/types.ts';
 
@@ -28,6 +32,32 @@ export class SchemaTransformUtil {
         }
         break;
       }
+      case 'mapped': {
+        const base = state.getOrImport(type);
+        const uniqueId = state.generateUniqueIdentifier(node, type, 'Δ');
+        const [id, existing] = state.registerIdentifier(uniqueId);
+        if (!existing) {
+          const cls = state.factory.createClassDeclaration(
+            [
+              state.createDecorator(this.SCHEMA_IMPORT, 'Schema', state.fromLiteral({
+                description: type.comment,
+                mappedOperation: type.operation,
+                mappedFields: type.fields,
+              })),
+            ],
+            id, [], [state.factory.createHeritageClause(
+              ts.SyntaxKind.ExtendsKeyword, [state.factory.createExpressionWithTypeArguments(base, [])]
+            )], []
+          );
+          cls.getText = (): string => `
+class ${uniqueId} extends ${type.mappedClassName} { 
+  fields: ${type.fields?.join(', ')} 
+  operation: ${type.operation}
+}`;
+          state.addStatements([cls], root || node);
+        }
+        return id;
+      }
       case 'unknown': {
         const imp = state.importFile(this.TYPES_IMPORT);
         return state.createAccess(imp.ident, 'UnknownType');
@@ -40,18 +70,14 @@ export class SchemaTransformUtil {
         if (!existing) {
           const cls = state.factory.createClassDeclaration(
             [
-              state.createDecorator(this.SCHEMA_IMPORT, 'Schema'),
-              state.createDecorator(this.COMMON_IMPORT, 'Describe',
-                state.fromLiteral({
-                  title: type.name,
-                  description: type.comment
-                })
-              )
+              state.createDecorator(this.SCHEMA_IMPORT, 'Schema', state.fromLiteral({
+                description: type.comment
+              })),
             ],
             id, [], [],
             Object.entries(type.fieldTypes)
               .map(([k, v]) =>
-                this.computeField(state, state.factory.createPropertyDeclaration(
+                this.computeInput(state, state.factory.createPropertyDeclaration(
                   [], /\W/.test(k) ? state.factory.createComputedPropertyName(state.fromLiteral(k)) : k,
                   v.undefinable || v.nullable ? state.factory.createToken(ts.SyntaxKind.QuestionToken) : undefined,
                   v.key === 'unknown' ? state.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword) : undefined, undefined
@@ -83,45 +109,50 @@ export class SchemaTransformUtil {
   }
 
   /**
-   * Compute property information from declaration
+   * Compute decorator params from property/parameter/getter/setter
    */
-  static computeField<T extends ts.PropertyDeclaration | ts.ParameterDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration>(
-    state: TransformerState, node: T, config: { type?: AnyType, root?: ts.Node, name?: string } = { root: node }
-  ): T {
-
-    const typeExpr = config.type ?? state.resolveType(ts.isSetAccessor(node) ? node.parameters[0] : node);
-    const attrs: ts.PropertyAssignment[] = [];
+  static computeInputDecoratorParams<T extends ts.PropertyDeclaration | ts.ParameterDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration>(
+    state: TransformerState,
+    node: T,
+    config?: ComputeConfig
+  ): ts.Expression[] {
+    const typeExpr = config?.type ?? state.resolveType(ts.isSetAccessor(node) ? node.parameters[0] : node);
+    const attrs: Record<string, string | boolean | object | number | ts.Expression> = {};
 
     if (!ts.isGetAccessorDeclaration(node) && !ts.isSetAccessorDeclaration(node)) {
       // eslint-disable-next-line no-bitwise
       if ((ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Readonly) > 0) {
-        attrs.push(state.factory.createPropertyAssignment('access', state.fromLiteral('readonly')));
-      } else if (!node.questionToken && !typeExpr.undefinable && !node.initializer) {
-        attrs.push(state.factory.createPropertyAssignment('required', state.fromLiteral({ active: true })));
+        attrs.access = 'readonly';
+      } else if (!!node.questionToken || !!typeExpr.undefinable || !!node.initializer) {
+        attrs.required = { active: false };
       }
-      if (node.initializer && (
+      if (node.initializer !== undefined && (
         ts.isLiteralExpression(node.initializer) ||
+        node.initializer.kind === ts.SyntaxKind.TrueKeyword ||
+        node.initializer.kind === ts.SyntaxKind.FalseKeyword ||
         (ts.isArrayLiteralExpression(node.initializer) && node.initializer.elements.length === 0)
       )) {
-        attrs.push(state.factory.createPropertyAssignment('default', node.initializer));
+        attrs.default = node.initializer;
       }
     } else {
       const acc = DeclarationUtil.getAccessorPair(node);
-      attrs.push(state.factory.createPropertyAssignment('accessor', state.fromLiteral(true)));
+      attrs.accessor = true;
       if (!acc.setter) {
-        attrs.push(state.factory.createPropertyAssignment('access', state.fromLiteral('readonly')));
+        attrs.access = 'readonly';
       }
       if (!acc.getter) {
-        attrs.push(state.factory.createPropertyAssignment('access', state.fromLiteral('writeonly')));
-      } else if (!typeExpr.undefinable) {
-        attrs.push(state.factory.createPropertyAssignment('required', state.fromLiteral({ active: true })));
+        attrs.access = 'writeonly';
+      } else if (!!typeExpr.undefinable) {
+        attrs.required = { active: false };
       }
     }
 
-    if (ts.isParameter(node) || config.name !== undefined) {
-      attrs.push(state.factory.createPropertyAssignment('name', state.factory.createStringLiteral(
-        config.name !== undefined ? config.name : node.name.getText())
-      ));
+    const rawName = node.getSourceFile()?.text ? node.name.getText() ?? undefined : undefined;
+    const providedName = config?.name ?? rawName!;
+    attrs.name = providedName;
+
+    if (rawName !== providedName && rawName) {
+      attrs.sourceText = rawName;
     }
 
     const primaryExpr = typeExpr.key === 'literal' && typeExpr.typeArguments?.[0] ? typeExpr.typeArguments[0] : typeExpr;
@@ -133,79 +164,107 @@ export class SchemaTransformUtil {
         .filter(x => x !== undefined && x !== null);
 
       if (values.length === primaryExpr.subTypes.length) {
-        attrs.push(state.factory.createPropertyAssignment('enum', state.fromLiteral({
+        attrs.enum = {
           values,
           message: `{path} is only allowed to be "${values.join('" or "')}"`
-        })));
+        };
       }
     } else if (primaryExpr.key === 'template' && primaryExpr.template) {
       const re = LiteralUtil.templateLiteralToRegex(primaryExpr.template);
-      attrs.push(state.factory.createPropertyAssignment('match', state.fromLiteral({
+      attrs.match = {
         re: new RegExp(re),
         template: primaryExpr.template,
         message: `{path} must match "${re}"`
-      })));
+      };
     }
 
     if (ts.isParameter(node)) {
-      const comments = DocUtil.describeDocs(node.parent);
-      const commentConfig: Partial<ParamDocumentation> = (comments.params ?? []).find(x => x.name === node.name.getText()) || {};
-      if (commentConfig.description) {
-        attrs.push(state.factory.createPropertyAssignment('description', state.fromLiteral(commentConfig.description)));
+      const parentComments = DocUtil.describeDocs(node.parent);
+      const paramComments: Partial<ParamDocumentation> = (parentComments.params ?? []).find(x => x.name === node.name.getText()) || {};
+      if (paramComments.description) {
+        attrs.description = paramComments.description;
+      }
+    } else {
+      const comments = DocUtil.describeDocs(node);
+      if (comments.description) {
+        attrs.description = comments.description;
       }
     }
 
     const tags = ts.getJSDocTags(node);
     const aliases = tags.filter(x => x.tagName.getText() === 'alias');
     if (aliases.length) {
-      attrs.push(state.factory.createPropertyAssignment('aliases', state.fromLiteral(aliases.map(x => x.comment).filter(x => !!x))));
+      attrs.aliases = aliases.map(x => x.comment).filter(x => !!x);
     }
 
     const params: ts.Expression[] = [];
 
-    const existing = state.findDecorator('@travetto/schema', node, 'Field', this.FIELD_IMPORT);
+    const existing =
+      state.findDecorator('@travetto/schema', node, 'Field', this.FIELD_IMPORT) ??
+      state.findDecorator('@travetto/schema', node, 'Input', this.INPUT_IMPORT);
+
+    if (config?.index !== undefined) {
+      attrs.index = config.index;
+    }
+
+    if (Object.keys(attrs).length) {
+      params.push(state.fromLiteral(attrs));
+    }
+
     if (!existing) {
-      const resolved = this.toConcreteType(state, typeExpr, node, config.root);
-      params.push(resolved);
-      if (attrs.length) {
-        params.push(state.factory.createObjectLiteralExpression(attrs));
-      }
+      const resolved = this.toConcreteType(state, typeExpr, node, config?.root ?? node);
+      const type = typeExpr.key === 'foreign' ? state.getConcreteType(node) :
+        ts.isArrayLiteralExpression(resolved) ? resolved.elements[0] : resolved;
+
+      params.unshift(LiteralUtil.fromLiteral(state.factory, {
+        array: ts.isArrayLiteralExpression(resolved),
+        type
+      }));
     } else {
       const args = DecoratorUtil.getArguments(existing) ?? [];
       if (args.length > 0) {
-        params.push(args[0]);
+        params.unshift(args[0]);
       }
-      params.push(state.factory.createObjectLiteralExpression(attrs));
       if (args.length > 1) {
         params.push(...args.slice(1));
       }
     }
 
-    const newModifiers = [
-      ...(node.modifiers ?? []).filter(x => x !== existing),
-      state.createDecorator(this.FIELD_IMPORT, 'Field', ...params)
-    ];
+    return params;
+  }
+
+  /**
+   * Compute property information from declaration
+   */
+  static computeInput<T extends ts.PropertyDeclaration | ts.ParameterDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration>(
+    state: TransformerState, node: T, config?: ComputeConfig
+  ): T {
+    const existingField = state.findDecorator('@travetto/schema', node, 'Field', this.FIELD_IMPORT);
+    const existingInput = state.findDecorator('@travetto/schema', node, 'Input', this.INPUT_IMPORT);
+    const decParams = this.computeInputDecoratorParams(state, node, config);
+
+    let modifiers: ts.ModifierLike[];
+    if (existingField) {
+      const dec = state.createDecorator(this.FIELD_IMPORT, 'Field', ...decParams);
+      modifiers = DecoratorUtil.spliceDecorators(node, existingField, [dec]);
+    } else {
+      const dec = state.createDecorator(this.INPUT_IMPORT, 'Input', ...decParams);
+      modifiers = DecoratorUtil.spliceDecorators(node, existingInput, [dec]);
+    }
 
     let result: unknown;
     if (ts.isPropertyDeclaration(node)) {
-      const comments = DocUtil.describeDocs(node);
-      if (comments.description) {
-        newModifiers.push(state.createDecorator(this.COMMON_IMPORT, 'Describe', state.fromLiteral({
-          description: comments.description
-        })));
-      }
-
       result = state.factory.updatePropertyDeclaration(node,
-        newModifiers, node.name, node.questionToken, node.type, node.initializer);
+        modifiers, node.name, node.questionToken, node.type, node.initializer);
     } else if (ts.isParameter(node)) {
       result = state.factory.updateParameterDeclaration(node,
-        newModifiers, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer);
+        modifiers, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer);
     } else if (ts.isGetAccessorDeclaration(node)) {
       result = state.factory.updateGetAccessorDeclaration(node,
-        newModifiers, node.name, node.parameters, node.type, node.body);
+        modifiers, node.name, node.parameters, node.type, node.body);
     } else {
       result = state.factory.updateSetAccessorDeclaration(node,
-        newModifiers, node.name, node.parameters, node.body);
+        modifiers, node.name, node.parameters, node.body);
     }
     return transformCast(result);
   }
@@ -233,7 +292,12 @@ export class SchemaTransformUtil {
   static ensureType(state: TransformerState, anyType: AnyType, target: ts.Node): Record<string, unknown> {
     const { out, type } = this.unwrapType(anyType);
     switch (type?.key) {
+      case 'foreign': {
+        out.type = state.getForeignTarget(type);
+        break;
+      }
       case 'managed': out.type = state.typeToIdentifier(type); break;
+      case 'mapped': out.type = this.toConcreteType(state, type, target); break;
       case 'shape': out.type = this.toConcreteType(state, type, target); break;
       case 'template': out.type = state.factory.createIdentifier(type.ctor.name); break;
       case 'literal': {
@@ -270,4 +334,26 @@ export class SchemaTransformUtil {
       return state.findMethodByName(cls, methodName);
     }
   }
+
+  /**
+   * Compute return type decorator params
+   */
+  static computeReturnTypeDecoratorParams(state: TransformerState, node: ts.MethodDeclaration): ts.Expression[] {
+    // If we have a valid response type, declare it
+    const returnType = state.resolveReturnType(node);
+    let targetType = returnType;
+
+    if (returnType.key === 'literal' && returnType.typeArguments?.length && returnType.name === 'Promise') {
+      targetType = returnType.typeArguments[0];
+    }
+
+    // TODO: Standardize this using jsdoc
+    let innerReturnType: AnyType | undefined;
+    if (targetType.key === 'managed' && targetType.importName.startsWith('@travetto/')) {
+      innerReturnType = state.getApparentTypeOfField(targetType.original!, 'body');
+    }
+
+    const finalReturnType = SchemaTransformUtil.ensureType(state, innerReturnType ?? returnType, node);
+    return finalReturnType ? [state.fromLiteral({ returnType: finalReturnType })] : [];
+  }
 }

package/support/transformer.schema.ts

@@ -1,17 +1,20 @@
 import ts from 'typescript';
 
 import {
-  TransformerState, OnProperty, OnClass, AfterClass, DocUtil, DeclarationUtil, OnGetter, OnSetter,
-  DecoratorUtil
+  TransformerState, OnProperty, OnClass, AfterClass, DocUtil, DeclarationUtil,
+  OnGetter, OnSetter, OnMethod, DecoratorUtil, OnStaticMethod
 } from '@travetto/transformer';
 
 import { SchemaTransformUtil } from './transformer/util.ts';
 
+const CONSTRUCTOR_PROPERTY = 'CONSTRUCTOR';
 const InSchemaSymbol = Symbol();
 const AccessorsSymbol = Symbol();
+const AutoEnrollMethods = Symbol();
 
 interface AutoState {
   [InSchemaSymbol]?: boolean;
+  [AutoEnrollMethods]?: Set<string>;
   [AccessorsSymbol]?: Set<string>;
 }
 
@@ -20,6 +23,30 @@ interface AutoState {
  */
 export class SchemaTransformer {
 
+  static isInvisible(state: AutoState & TransformerState, node: ts.Declaration): boolean {
+    const ignore = state.findDecorator(this, node, 'Ignore');
+    if (ignore) {
+      return true;
+    }
+
+    const manuallyOpted = !!(
+      state.findDecorator(this, node, 'Input') ??
+      state.findDecorator(this, node, 'Method')
+    );
+    if (manuallyOpted) {
+      return false;
+    }
+    if (ts.isMethodDeclaration(node)) {
+      if (!node.body || !state[AutoEnrollMethods]?.has(node.name.getText())) {
+        return true;
+      }
+    }
+    if (!state[InSchemaSymbol] || !DeclarationUtil.isPublic(node)) {
+      return true;
+    }
+    return false;
+  }
+
   /**
    * Track schema on start
    */
@@ -27,6 +54,17 @@ export class SchemaTransformer {
   static startSchema(state: AutoState & TransformerState, node: ts.ClassDeclaration): ts.ClassDeclaration {
     state[InSchemaSymbol] = true;
     state[AccessorsSymbol] = new Set();
+    state[AutoEnrollMethods] = new Set();
+
+    // Determine auto enrol methods
+    for (const item of state.getDecoratorList(node)) {
+      if (item.targets?.includes('@travetto/schema:Schema')) {
+        for (const opt of item.options ?? []) {
+          state[AutoEnrollMethods].add(opt);
+        }
+      }
+    }
+
     return node;
   }
 
@@ -35,56 +73,99 @@ export class SchemaTransformer {
    */
   @AfterClass('Schema')
   static finalizeSchema(state: AutoState & TransformerState, node: ts.ClassDeclaration): ts.ClassDeclaration {
-    const modifiers = (node.modifiers ?? []).slice(0);
-
     const comments = DocUtil.describeDocs(node);
 
-    if (!state.findDecorator(this, node, 'Schema', SchemaTransformUtil.SCHEMA_IMPORT)) {
-      modifiers.unshift(state.createDecorator(SchemaTransformUtil.SCHEMA_IMPORT, 'Schema'));
-    }
+    const existing = state.findDecorator(this, node, 'Schema', SchemaTransformUtil.SCHEMA_IMPORT);
+    const cons = node.members.find(x => ts.isConstructorDeclaration(x));
+
+    const attrs: Record<string, string | boolean | ts.Expression | number | object | unknown[]> = {};
 
     if (comments.description) {
-      modifiers.push(state.createDecorator(SchemaTransformUtil.COMMON_IMPORT, 'Describe', state.fromLiteral({
-        title: comments.description
-      })));
+      attrs.description = comments.description;
+    }
+
+    // Extract all interfaces
+    const interfaces: ts.Node[] = [];
+    for (const clause of node.heritageClauses ?? []) {
+      if (clause.token === ts.SyntaxKind.ImplementsKeyword) {
+        for (const typeExpression of clause.types) {
+          const resolvedType = state.resolveType(typeExpression);
+          if (resolvedType.key === 'managed') {
+            const resolved = state.getOrImport(resolvedType);
+            interfaces.push(resolved);
+          }
+        }
+      }
+    }
+
+    if (interfaces.length > 0) {
+      attrs.interfaces = interfaces;
+    }
+
+    if (cons) {
+      attrs.methods = {
+        [CONSTRUCTOR_PROPERTY]: {
+          parameters: cons.parameters.map((p, i) => SchemaTransformUtil.computeInputDecoratorParams(state, p, { index: i })).map(x =>
+            state.extendObjectLiteral({}, ...x)
+          ),
+        }
+      };
+    }
+
+    let params = DecoratorUtil.getArguments(existing) ?? [];
+    if (Object.keys(attrs).length) {
+      params = [...params, state.fromLiteral(attrs)];
     }
 
     delete state[InSchemaSymbol];
     delete state[AccessorsSymbol];
-    let members = node.members;
-
-    const schemaMethods = [
-      ...node.modifiers?.filter(x => ts.isDecorator(x))
-        .flatMap(x => state.getDeclarations(DecoratorUtil.getDecoratorIdent(x))) ?? [],
-      node
-    ]
-      .flatMap(v => state.readDocTagList(v, 'schemaMethods'));
-
-    if (schemaMethods.length) {
-      const methodSet = new Set(schemaMethods.flatMap(x => x.split(/\s*,\s*/g)));
-      members = state.factory.createNodeArray(
-        node.members.map(x => ts.isMethodDeclaration(x) && methodSet.has(x.name.getText()) ?
-          state.factory.updateMethodDeclaration(
-            x,
-            x.modifiers,
-            x.asteriskToken,
-            x.name,
-            x.questionToken,
-            x.typeParameters,
-            x.parameters.map(y => SchemaTransformUtil.computeField(state, y)),
-            x.type,
-            x.body
-          ) : x)
-      );
-    }
 
     return state.factory.updateClassDeclaration(
       node,
-      modifiers,
+      DecoratorUtil.spliceDecorators(node, existing, [
+        state.createDecorator(SchemaTransformUtil.SCHEMA_IMPORT, 'Schema', ...params)
+      ]),
       node.name,
       node.typeParameters,
       node.heritageClauses,
-      members
+      node.members
+    );
+  }
+
+  /**
+   * Handle explicitly registered methods
+   */
+  @OnMethod()
+  @OnStaticMethod()
+  static processSchemaMethod(state: TransformerState & AutoState, node: ts.MethodDeclaration): ts.MethodDeclaration {
+    if (this.isInvisible(state, node) && !state[AutoEnrollMethods]?.has(node.name.getText())) {
+      return node;
+    }
+
+    const existing = state.findDecorator(this, node, 'Method', SchemaTransformUtil.METHOD_IMPORT);
+    const comments = DocUtil.describeDocs(node);
+    const params = DecoratorUtil.getArguments(existing) ?? [];
+
+    if (comments.description) {
+      params.unshift(state.fromLiteral({ description: comments.description }));
+    }
+    if (DeclarationUtil.isStatic(node)) {
+      params.push(state.fromLiteral({ isStatic: true }));
+    }
+    params.push(...SchemaTransformUtil.computeReturnTypeDecoratorParams(state, node));
+
+    return state.factory.updateMethodDeclaration(
+      node,
+      DecoratorUtil.spliceDecorators(node, existing, [
+        state.createDecorator(SchemaTransformUtil.METHOD_IMPORT, 'Method', ...params)
+      ]),
+      node.asteriskToken,
+      node.name,
+      node.questionToken,
+      node.typeParameters,
+      node.parameters.map((y, i) => SchemaTransformUtil.computeInput(state, y, { index: i })),
+      node.type,
+      node.body
     );
   }
 
@@ -93,9 +174,10 @@ export class SchemaTransformer {
    */
   @OnProperty()
   static processSchemaField(state: TransformerState & AutoState, node: ts.PropertyDeclaration): ts.PropertyDeclaration {
-    const ignore = state.findDecorator(this, node, 'Ignore');
-    return state[InSchemaSymbol] && !ignore && DeclarationUtil.isPublic(node) ?
-      SchemaTransformUtil.computeField(state, node) : node;
+    if (this.isInvisible(state, node)) {
+      return node;
+    }
+    return SchemaTransformUtil.computeInput(state, node);
   }
 
   /**
@@ -103,12 +185,15 @@ export class SchemaTransformer {
    */
   @OnGetter()
   static processSchemaGetter(state: TransformerState & AutoState, node: ts.GetAccessorDeclaration): ts.GetAccessorDeclaration {
-    const ignore = state.findDecorator(this, node, 'Ignore');
-    if (state[InSchemaSymbol] && !ignore && DeclarationUtil.isPublic(node) && !state[AccessorsSymbol]?.has(node.name.getText())) {
+    if (this.isInvisible(state, node) || DeclarationUtil.isStatic(node)) {
+      return node;
+    }
+    if (state[AccessorsSymbol]?.has(node.name.getText())) {
+      return node;
+    } else {
       state[AccessorsSymbol]?.add(node.name.getText());
-      return SchemaTransformUtil.computeField(state, node);
+      return SchemaTransformUtil.computeInput(state, node);
     }
-    return node;
   }
 
   /**
@@ -116,11 +201,14 @@ export class SchemaTransformer {
    */
   @OnSetter()
   static processSchemaSetter(state: TransformerState & AutoState, node: ts.SetAccessorDeclaration): ts.SetAccessorDeclaration {
-    const ignore = state.findDecorator(this, node, 'Ignore');
-    if (state[InSchemaSymbol] && !ignore && DeclarationUtil.isPublic(node) && !state[AccessorsSymbol]?.has(node.name.getText())) {
+    if (this.isInvisible(state, node) || DeclarationUtil.isStatic(node)) {
+      return node;
+    }
+    if (state[AccessorsSymbol]?.has(node.name.getText())) {
+      return node;
+    } else {
       state[AccessorsSymbol]?.add(node.name.getText());
-      return SchemaTransformUtil.computeField(state, node);
+      return SchemaTransformUtil.computeInput(state, node);
     }
-    return node;
   }
 }