typia 6.10.0 → 7.0.0-dev.20240916

package/src/transformers/features/RandomTransformer.ts

@@ -2,43 +2,40 @@ import ts from "typescript";
 
 import { RandomProgrammer } from "../../programmers/RandomProgrammer";
 
-import { IProject } from "../IProject";
+import { ITransformProps } from "../ITransformProps";
 import { TransformerError } from "../TransformerError";
 
 export namespace RandomTransformer {
-  export const transform =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (expression: ts.CallExpression): ts.Expression => {
-      // CHECK GENERIC ARGUMENT EXISTENCE
-      if (!expression.typeArguments?.[0])
-        throw new TransformerError({
-          code: `typia.${modulo.getText()}`,
-          message: "generic argument is not specified.",
-        });
+  export const transform = (props: ITransformProps): ts.Expression => {
+    // CHECK GENERIC ARGUMENT EXISTENCE
+    if (!props.expression.typeArguments?.[0])
+      throw new TransformerError({
+        code: `typia.${props.modulo.getText()}`,
+        message: "generic argument is not specified.",
+      });
 
-      // GET TYPE INFO
-      const node: ts.TypeNode = expression.typeArguments[0];
-      const type: ts.Type = project.checker.getTypeFromTypeNode(node);
+    // GET TYPE INFO
+    const node: ts.TypeNode = props.expression.typeArguments[0];
+    const type: ts.Type = props.context.checker.getTypeFromTypeNode(node);
 
-      if (type.isTypeParameter())
-        throw new TransformerError({
-          code: `typia.${modulo.getText()}`,
-          message: "non-specified generic argument.",
-        });
+    if (type.isTypeParameter())
+      throw new TransformerError({
+        code: `typia.${props.modulo.getText()}`,
+        message: "non-specified generic argument.",
+      });
 
-      // DO TRANSFORM
-      return ts.factory.createCallExpression(
-        RandomProgrammer.write({
-          ...project,
-          options: {
-            ...project.options,
-            functional: false,
-            numeric: false,
-          },
-        })(modulo)()(type, node.getFullText().trim()),
-        undefined,
-        expression.arguments.length ? [expression.arguments[0]!] : undefined,
-      );
-    };
+    return ts.factory.createCallExpression(
+      RandomProgrammer.write({
+        context: props.context,
+        modulo: props.modulo,
+        type,
+        name: node.getFullText().trim(),
+        init: undefined,
+      }),
+      undefined,
+      props.expression.arguments.length
+        ? [props.expression.arguments[0]!]
+        : undefined,
+    );
+  };
 }

package/src/transformers/features/ValidateTransformer.ts

@@ -1,11 +1,18 @@
 import { ValidateProgrammer } from "../../programmers/ValidateProgrammer";
 
+import { ITransformProps } from "../ITransformProps";
 import { GenericTransformer } from "../internal/GenericTransformer";
 
 export namespace ValidateTransformer {
-  export const transform = (equals: boolean) =>
-    GenericTransformer.scalar(equals ? "validateEquals" : "validate")(
-      (project) => (modulo) =>
-        ValidateProgrammer.write(project)(modulo)(equals),
-    );
+  export const transform =
+    (config: ValidateProgrammer.IConfig) => (props: ITransformProps) =>
+      GenericTransformer.scalar({
+        ...props,
+        method: config.equals ? "validateEquals" : "validate",
+        write: (x) =>
+          ValidateProgrammer.write({
+            ...x,
+            config,
+          }),
+      });
 }

package/src/transformers/features/functional/FunctionalGenericTransformer.ts

@@ -2,56 +2,56 @@ import ts from "typescript";
 
 import { TypeFactory } from "../../../factories/TypeFactory";
 
-import { IProject } from "../../IProject";
+import { ITransformProps } from "../../ITransformProps";
+import { ITypiaContext } from "../../ITypiaContext";
 import { TransformerError } from "../../TransformerError";
 
 export namespace FunctionalGenericTransformer {
+  export interface IConfig {
+    equals: boolean;
+  }
+  export interface ISpecification {
+    method: string;
+    config: IConfig;
+    programmer: (p: {
+      context: ITypiaContext;
+      modulo: ts.LeftHandSideExpression;
+      expression: ts.Expression;
+      declaration: ts.FunctionDeclaration;
+      config: IConfig;
+      init?: ts.Expression;
+    }) => ts.Expression;
+  }
   export const transform =
-    (props: {
-      method: string;
-      programmer: (
-        project: IProject,
-      ) => (
-        modulo: ts.LeftHandSideExpression,
-      ) => (
-        equals: boolean,
-      ) => (
-        expression: ts.Expression,
-        declaration: ts.FunctionDeclaration,
-        init?: ts.Expression,
-      ) => ts.Expression;
-      equals: boolean;
-    }) =>
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (expression: ts.CallExpression) => {
+    (spec: ISpecification) =>
+    (props: ITransformProps): ts.Expression => {
       // CHECK PARAMETER
-      if (expression.arguments.length === 0)
+      if (props.expression.arguments.length === 0)
         throw new TransformerError({
-          code: `typia.functional.${props.method}`,
+          code: `typia.functional.${spec.method}`,
           message: `no input value.`,
         });
 
       // GET TYPE INFO
       const type: ts.Type =
-        expression.typeArguments && expression.typeArguments[0]
-          ? project.checker.getTypeFromTypeNode(expression.typeArguments[0])
-          : project.checker.getTypeAtLocation(expression.arguments[0]!);
-      // if (type. === true)
-      //   throw new TransformerError({
-      //     code: `typia.functional.${props.method}`,
-      //     message: `non-specified generic argument.`,
-      //   });
-      // else
+        props.expression.typeArguments && props.expression.typeArguments[0]
+          ? props.context.checker.getTypeFromTypeNode(
+              props.expression.typeArguments[0],
+            )
+          : props.context.checker.getTypeAtLocation(
+              props.expression.arguments[0]!,
+            );
       if (TypeFactory.isFunction(type) === false)
         throw new TransformerError({
-          code: `typia.functional.${props.method}`,
+          code: `typia.functional.${spec.method}`,
           message: `input value is not a function.`,
         });
-      return props.programmer(project)(modulo)(props.equals)(
-        expression.arguments[0]!,
-        type.symbol!.declarations![0] as ts.FunctionDeclaration,
-        expression.arguments[1],
-      );
+      return spec.programmer({
+        ...props,
+        config: spec.config,
+        expression: props.expression.arguments[0] as ts.Expression,
+        declaration: type.symbol!.declarations![0] as ts.FunctionDeclaration,
+        init: props.expression.arguments[1],
+      });
     };
 }

package/src/transformers/features/http/CreateHttpAssertFormDataTransformer.ts

@@ -1,12 +1,13 @@
 import { HttpAssertFormDataProgrammer } from "../../../programmers/http/HttpAssertFormDataProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateHttpAssertFormDataTransformer {
-  export const transform = GenericTransformer.factory(
-    "http.createAssertFormData",
-  )(
-    (project) => (modulo) =>
-      HttpAssertFormDataProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "http.createAssertFormData",
+      write: HttpAssertFormDataProgrammer.write,
+    });
 }

package/src/transformers/features/http/CreateHttpAssertHeadersTransformer.ts

@@ -1,11 +1,13 @@
 import { HttpAssertHeadersProgrammer } from "../../../programmers/http/HttpAssertHeadersProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateHttpAssertHeadersTransformer {
-  export const transform = GenericTransformer.factory(
-    "http.createAssertHeaders",
-  )(
-    (project) => (modulo) => HttpAssertHeadersProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "http.createAssertHeaders",
+      write: HttpAssertHeadersProgrammer.write,
+    });
 }

package/src/transformers/features/http/CreateHttpAssertQueryTransformer.ts

@@ -1,9 +1,13 @@
 import { HttpAssertQueryProgrammer } from "../../../programmers/http/HttpAssertQueryProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateHttpAssertQueryTransformer {
-  export const transform = GenericTransformer.factory("http.createAssertQuery")(
-    (project) => (modulo) => HttpAssertQueryProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "http.createAssertQuery",
+      write: HttpAssertQueryProgrammer.write,
+    });
 }

package/src/transformers/features/http/CreateHttpFormDataTransformer.ts

@@ -1,9 +1,13 @@
 import { HttpFormDataProgrammer } from "../../../programmers/http/HttpFormDataProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateHttpFormDataTransformer {
-  export const transform = GenericTransformer.factory("http.createFormData")(
-    (project) => (modulo) => HttpFormDataProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "http.createFormData",
+      write: HttpFormDataProgrammer.write,
+    });
 }

package/src/transformers/features/http/CreateHttpHeadersTransformer.ts

@@ -1,9 +1,13 @@
 import { HttpHeadersProgrammer } from "../../../programmers/http/HttpHeadersProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateHttpHeadersTransformer {
-  export const transform = GenericTransformer.factory("http.createHeaders")(
-    (project) => (modulo) => HttpHeadersProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "http.createHeaders",
+      write: HttpHeadersProgrammer.write,
+    });
 }

package/src/transformers/features/http/CreateHttpIsFormDataTransformer.ts

@@ -1,9 +1,13 @@
 import { HttpIsFormDataProgrammer } from "../../../programmers/http/HttpIsFormDataProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateHttpIsFormDataTransformer {
-  export const transform = GenericTransformer.factory("http.createIsFormData")(
-    (project) => (modulo) => HttpIsFormDataProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "http.createIsFormData",
+      write: HttpIsFormDataProgrammer.write,
+    });
 }

package/src/transformers/features/http/CreateHttpIsHeadersTransformer.ts

@@ -1,9 +1,13 @@
 import { HttpIsHeadersProgrammer } from "../../../programmers/http/HttpIsHeadersProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateHttpIsHeadersTransformer {
-  export const transform = GenericTransformer.factory("http.createIsHeaders")(
-    (project) => (modulo) => HttpIsHeadersProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "http.createIsHeaders",
+      write: HttpIsHeadersProgrammer.write,
+    });
 }

package/src/transformers/features/http/CreateHttpIsQueryTransformer.ts

@@ -1,9 +1,13 @@
 import { HttpIsQueryProgrammer } from "../../../programmers/http/HttpIsQueryProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateHttpIsQueryTransformer {
-  export const transform = GenericTransformer.factory("http.createIsQuery")(
-    (project) => (modulo) => HttpIsQueryProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "http.createIsQuery",
+      write: HttpIsQueryProgrammer.write,
+    });
 }

package/src/transformers/features/http/CreateHttpParameterTransformer.ts

@@ -1,9 +1,13 @@
 import { HttpParameterProgrammer } from "../../../programmers/http/HttpParameterProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateHttpParameterTransformer {
-  export const transform = GenericTransformer.factory("http.createParameter")(
-    (project) => (modulo) => HttpParameterProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "http.createParameter",
+      write: HttpParameterProgrammer.write,
+    });
 }

package/src/transformers/features/http/CreateHttpQueryTransformer.ts

@@ -1,9 +1,13 @@
 import { HttpQueryProgrammer } from "../../../programmers/http/HttpQueryProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateHttpQueryTransformer {
-  export const transform = GenericTransformer.factory("http.createQuery")(
-    (project) => (modulo) => HttpQueryProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "http.createQuery",
+      write: HttpQueryProgrammer.write,
+    });
 }

package/src/transformers/features/http/CreateHttpValidateFormDataTransformer.ts

@@ -1,12 +1,13 @@
 import { HttpValidateFormDataProgrammer } from "../../../programmers/http/HttpValidateFormDataProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateHttpValidateFormDataTransformer {
-  export const transform = GenericTransformer.factory(
-    "http.createValidateFormData",
-  )(
-    (project) => (modulo) =>
-      HttpValidateFormDataProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "http.createValidateFormData",
+      write: HttpValidateFormDataProgrammer.write,
+    });
 }

package/src/transformers/features/http/CreateHttpValidateHeadersTransformer.ts

@@ -1,12 +1,13 @@
 import { HttpValidateHeadersProgrammer } from "../../../programmers/http/HttpValidateHeadersProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateHttpValidateHeadersTransformer {
-  export const transform = GenericTransformer.factory(
-    "http.createValidateHeaders",
-  )(
-    (project) => (modulo) =>
-      HttpValidateHeadersProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "http.createValidateHeaders",
+      write: HttpValidateHeadersProgrammer.write,
+    });
 }

package/src/transformers/features/http/CreateHttpValidateQueryTransformer.ts

@@ -1,11 +1,13 @@
 import { HttpValidateQueryProgrammer } from "../../../programmers/http/HttpValidateQueryProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateHttpValidateQueryTransformer {
-  export const transform = GenericTransformer.factory(
-    "http.createValidateQuery",
-  )(
-    (project) => (modulo) => HttpValidateQueryProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "http.createValidateQuery",
+      write: HttpValidateQueryProgrammer.write,
+    });
 }

package/src/transformers/features/http/HttpAssertFormDataTransformer.ts

@@ -1,10 +1,13 @@
 import { HttpAssertFormDataProgrammer } from "../../../programmers/http/HttpAssertFormDataProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace HttpAssertFormDataTransformer {
-  export const transform = GenericTransformer.scalar("http.assertFormData")(
-    (project) => (modulo) =>
-      HttpAssertFormDataProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "http.assertFormData",
+      write: HttpAssertFormDataProgrammer.write,
+    });
 }

package/src/transformers/features/http/HttpAssertHeadersTransformer.ts

@@ -1,9 +1,13 @@
 import { HttpAssertHeadersProgrammer } from "../../../programmers/http/HttpAssertHeadersProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace HttpAssertHeadersTransformer {
-  export const transform = GenericTransformer.scalar("http.assertHeaders")(
-    (project) => (modulo) => HttpAssertHeadersProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "http.assertHeaders",
+      write: HttpAssertHeadersProgrammer.write,
+    });
 }

package/src/transformers/features/http/HttpAssertQueryTransformer.ts

@@ -1,9 +1,13 @@
 import { HttpAssertQueryProgrammer } from "../../../programmers/http/HttpAssertQueryProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace HttpAssertQueryTransformer {
-  export const transform = GenericTransformer.scalar("http.assertQuery")(
-    (project) => (modulo) => HttpAssertQueryProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "http.assertQuery",
+      write: HttpAssertQueryProgrammer.write,
+    });
 }

package/src/transformers/features/http/HttpFormDataTransformer.ts

@@ -1,9 +1,13 @@
 import { HttpFormDataProgrammer } from "../../../programmers/http/HttpFormDataProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace HttpFormDataTransformer {
-  export const transform = GenericTransformer.scalar("http.formdata")(
-    (project) => (modulo) => HttpFormDataProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "http.formdata",
+      write: HttpFormDataProgrammer.write,
+    });
 }

package/src/transformers/features/http/HttpHeadersTransformer.ts

@@ -1,9 +1,13 @@
 import { HttpHeadersProgrammer } from "../../../programmers/http/HttpHeadersProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace HttpHeadersTransformer {
-  export const transform = GenericTransformer.scalar("http.headers")(
-    (project) => (modulo) => HttpHeadersProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "http.headers",
+      write: HttpHeadersProgrammer.write,
+    });
 }

package/src/transformers/features/http/HttpIsFormDataTransformer.ts

@@ -1,9 +1,13 @@
 import { HttpIsFormDataProgrammer } from "../../../programmers/http/HttpIsFormDataProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace HttpIsFormDataTransformer {
-  export const transform = GenericTransformer.scalar("http.isFormData")(
-    (project) => (modulo) => HttpIsFormDataProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "http.isFormData",
+      write: HttpIsFormDataProgrammer.write,
+    });
 }

package/src/transformers/features/http/HttpIsHeadersTransformer.ts

@@ -1,9 +1,13 @@
 import { HttpIsHeadersProgrammer } from "../../../programmers/http/HttpIsHeadersProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace HttpIsHeadersTransformer {
-  export const transform = GenericTransformer.scalar("http.isHeaders")(
-    (project) => (modulo) => HttpIsHeadersProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "http.isHeaders",
+      write: HttpIsHeadersProgrammer.write,
+    });
 }

package/src/transformers/features/http/HttpIsQueryTransformer.ts

@@ -1,9 +1,13 @@
 import { HttpIsQueryProgrammer } from "../../../programmers/http/HttpIsQueryProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace HttpIsQueryTransformer {
-  export const transform = GenericTransformer.scalar("http.isQuery")(
-    (project) => (modulo) => HttpIsQueryProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "http.isQuery",
+      write: HttpIsQueryProgrammer.write,
+    });
 }

package/src/transformers/features/http/HttpParameterTransformer.ts

@@ -1,9 +1,13 @@
 import { HttpParameterProgrammer } from "../../../programmers/http/HttpParameterProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace HttpParameterTransformer {
-  export const transform = GenericTransformer.scalar("http.parameter")(
-    (project) => (modulo) => HttpParameterProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "http.parameter",
+      write: HttpParameterProgrammer.write,
+    });
 }

package/src/transformers/features/http/HttpQueryTransformer.ts

@@ -1,9 +1,13 @@
 import { HttpQueryProgrammer } from "../../../programmers/http/HttpQueryProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace HttpQueryTransformer {
-  export const transform = GenericTransformer.scalar("http.query")(
-    (project) => (modulo) => HttpQueryProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "http.query",
+      write: HttpQueryProgrammer.write,
+    });
 }

package/src/transformers/features/http/HttpValidateFormDataTransformer.ts

@@ -1,10 +1,13 @@
 import { HttpValidateFormDataProgrammer } from "../../../programmers/http/HttpValidateFormDataProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace HttpValidateFormDataTransformer {
-  export const transform = GenericTransformer.scalar("http.validateFormData")(
-    (project) => (modulo) =>
-      HttpValidateFormDataProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "http.validateFormData",
+      write: HttpValidateFormDataProgrammer.write,
+    });
 }