@nestia/sdk 2.5.0-dev.20240129 → 2.5.0-dev.20240130

package/src/generates/internal/SdkAliasCollection.ts

@@ -0,0 +1,145 @@
+import ts from "typescript";
+
+import { INestiaConfig } from "../../INestiaConfig";
+import { IRoute } from "../../structures/IRoute";
+import { ImportDictionary } from "../../utils/ImportDictionary";
+import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
+
+export namespace SdkAliasCollection {
+  export const name =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (p: IRoute.IParameter | IRoute.IOutput): ts.TypeNode =>
+      p.metadata
+        ? SdkTypeProgrammer.decode(config)(importer)(p.metadata)
+        : ts.factory.createTypeReferenceNode(p.typeName);
+
+  export const headers =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (param: IRoute.IParameter): ts.TypeNode => {
+      const type: ts.TypeNode = name(config)(importer)(param);
+      if (config.primitive === false) return type;
+      return ts.factory.createTypeReferenceNode(
+        importer.external({
+          type: true,
+          library: "@nestia/fetcher",
+          instance: "Resolved",
+        }),
+        [type],
+      );
+    };
+
+  export const query =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (param: IRoute.IParameter): ts.TypeNode => {
+      const type: ts.TypeNode = name(config)(importer)(param);
+      if (config.primitive === false) return type;
+      return ts.factory.createTypeReferenceNode(
+        importer.external({
+          type: true,
+          library: "@nestia/fetcher",
+          instance: "Resolved",
+        }),
+        [type],
+      );
+    };
+
+  export const input =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (param: IRoute.IParameter): ts.TypeNode => {
+      const type: ts.TypeNode = name(config)(importer)(param);
+      if (config.primitive === false) return type;
+      return ts.factory.createTypeReferenceNode(
+        importer.external({
+          type: true,
+          library: "@nestia/fetcher",
+          instance: "Primitive",
+        }),
+        [type],
+      );
+    };
+
+  export const output =
+    (checker: ts.TypeChecker) =>
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (route: IRoute): ts.TypeNode => {
+      if (config.propagate !== true) {
+        const node: ts.TypeNode = name(config)(importer)(route.output);
+        const type = checker.getTypeAtLocation(node);
+        const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+
+        if (
+          filter(ts.TypeFlags.Undefined) ||
+          filter(ts.TypeFlags.Never) ||
+          filter(ts.TypeFlags.Void) ||
+          filter(ts.TypeFlags.VoidLike) ||
+          config.primitive === false
+        )
+          return node;
+        return ts.factory.createTypeReferenceNode(
+          importer.external({
+            type: true,
+            library: "@nestia/fetcher",
+            instance:
+              route.output.contentType === "application/x-www-form-urlencoded"
+                ? "Resolved"
+                : "Primitive",
+          }),
+          [node],
+        );
+      }
+
+      const branches: IBranch[] = [
+        {
+          status: String(route.status ?? (route.method === "POST" ? 201 : 200)),
+          type: name(config)(importer)(route.output),
+        },
+        ...Object.entries(route.exceptions).map(([status, value]) => ({
+          status,
+          type: name(config)(importer)(value),
+        })),
+      ];
+      return ts.factory.createTypeReferenceNode(
+        importer.external({
+          type: true,
+          library: "@nestia/fetcher",
+          instance: "IPropagation",
+        }),
+        [
+          ts.factory.createTypeLiteralNode(
+            branches.map((b) =>
+              ts.factory.createPropertySignature(
+                undefined,
+                ts.factory.createNumericLiteral(b.status),
+                undefined,
+                b.type,
+              ),
+            ),
+          ),
+          ...(route.status
+            ? [
+                ts.factory.createLiteralTypeNode(
+                  ts.factory.createNumericLiteral(route.status),
+                ),
+              ]
+            : []),
+        ],
+      );
+    };
+
+  export const responseBody =
+    (checker: ts.TypeChecker) =>
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (route: IRoute): ts.TypeNode =>
+      output(checker)({ ...config, propagate: false })(importer)(route);
+}
+
+interface IBranch {
+  status: string;
+  type: ts.TypeNode;
+}

package/src/generates/internal/SdkFileProgrammer.ts

@@ -14,6 +14,7 @@ export namespace SdkFileProgrammer {
         CONSTRUCTOR
     --------------------------------------------------------- */
   export const generate =
+    (checker: ts.TypeChecker) =>
     (config: INestiaConfig) =>
     async (routeList: IRoute[]): Promise<void> => {
       // CONSTRUCT FOLDER TREE
@@ -21,7 +22,7 @@ export namespace SdkFileProgrammer {
       for (const route of routeList) emplace(root)(route);
 
       // ITERATE FILES
-      await iterate(config)(root)(config.output + "/functional");
+      await iterate(checker)(config)(root)(config.output + "/functional");
     };
 
   const emplace =
@@ -44,6 +45,7 @@ export namespace SdkFileProgrammer {
         FILE ITERATOR
     --------------------------------------------------------- */
   const iterate =
+    (checker: ts.TypeChecker) =>
     (config: INestiaConfig) =>
     (directory: SdkRouteDirectory) =>
     async (outDir: string): Promise<void> => {
@@ -55,7 +57,7 @@ export namespace SdkFileProgrammer {
       // ITERATE CHILDREN
       const statements: ts.Statement[] = [];
       for (const [key, value] of directory.children) {
-        await iterate(config)(value)(`${outDir}/${key}`);
+        await iterate(checker)(config)(value)(`${outDir}/${key}`);
         statements.push(
           ts.factory.createExportDeclaration(
             undefined,
@@ -92,7 +94,7 @@ export namespace SdkFileProgrammer {
                 type: true,
               });
         statements.push(
-          ...SdkRouteProgrammer.generate(config)(importer)(route),
+          ...SdkRouteProgrammer.generate(checker)(config)(importer)(route),
         );
         if (i !== directory.routes.length - 1)
           statements.push(FormatUtil.enter());

package/src/generates/internal/SdkFunctionProgrammer.ts

@@ -6,8 +6,8 @@ import { INestiaConfig } from "../../INestiaConfig";
 import { IController } from "../../structures/IController";
 import { IRoute } from "../../structures/IRoute";
 import { ImportDictionary } from "../../utils/ImportDictionary";
-import { SdkDtoGenerator } from "./SdkDtoGenerator";
 import { SdkImportWizard } from "./SdkImportWizard";
+import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
 
 export namespace SdkFunctionProgrammer {
   export const generate =
@@ -49,12 +49,12 @@ export namespace SdkFunctionProgrammer {
                 p.optional
                   ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
                   : undefined,
-                ts.factory.createTypeReferenceNode(
-                  config.primitive !== false &&
-                    (p === props.query || p === props.input)
-                    ? `${route.name}.${p === props.query ? "Query" : "Input"}`
-                    : getTypeName(config)(importer)(p),
-                ),
+                config.primitive !== false &&
+                  (p === props.query || p === props.input)
+                  ? ts.factory.createTypeReferenceNode(
+                      `${route.name}.${p === props.query ? "Query" : "Input"}`,
+                    )
+                  : getTypeName(config)(importer)(p),
               ),
             ),
         ],
@@ -215,5 +215,5 @@ const getTypeName =
   (importer: ImportDictionary) =>
   (p: IRoute.IParameter | IRoute.IOutput) =>
     p.metadata
-      ? SdkDtoGenerator.decode(config)(importer)(p.metadata)
-      : p.typeName;
+      ? SdkTypeProgrammer.decode(config)(importer)(p.metadata)
+      : ts.factory.createTypeReferenceNode(p.typeName);

package/src/generates/internal/SdkInterfaceProgrammer.ts

@@ -0,0 +1,211 @@
+import { IPointer } from "tstl";
+import ts from "typescript";
+import { IJsDocTagInfo } from "typia";
+import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
+import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
+import { MetadataAlias } from "typia/lib/schemas/metadata/MetadataAlias";
+import { MetadataAtomic } from "typia/lib/schemas/metadata/MetadataAtomic";
+import { MetadataObject } from "typia/lib/schemas/metadata/MetadataObject";
+import { MetadataProperty } from "typia/lib/schemas/metadata/MetadataProperty";
+import { Escaper } from "typia/lib/utils/Escaper";
+
+import { INestiaConfig } from "../../INestiaConfig";
+import { IRoute } from "../../structures/IRoute";
+import { FormatUtil } from "../../utils/FormatUtil";
+import { ImportDictionary } from "../../utils/ImportDictionary";
+import { MapUtil } from "../../utils/MapUtil";
+import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
+
+export namespace SdkInterfaceProgrammer {
+  export interface IModule {
+    name: string;
+    children: Map<string, IModule>;
+    programmer:
+      | null
+      | ((importer: ImportDictionary) => ts.TypeAliasDeclaration);
+  }
+
+  export const generate =
+    (checker: ts.TypeChecker) =>
+    (config: INestiaConfig) =>
+    (routes: IRoute[]): Map<string, IModule> => {
+      const collection = new MetadataCollection({
+        replace: MetadataCollection.replace,
+      });
+      for (const r of routes) {
+        for (const p of r.parameters) {
+          const res = MetadataFactory.analyze(checker)({
+            escape: false,
+            constant: true,
+            absorb: false,
+          })(collection)(p.type);
+          if (res.success) p.metadata = res.data;
+        }
+        for (const e of Object.values(r.exceptions)) {
+          const res = MetadataFactory.analyze(checker)({
+            escape: true,
+            constant: true,
+            absorb: false,
+          })(collection)(e.type);
+          if (res.success) e.metadata = res.data;
+        }
+        const res = MetadataFactory.analyze(checker)({
+          escape: true,
+          constant: true,
+          absorb: false,
+        })(collection)(r.output.type);
+        if (res.success) r.output.metadata = res.data;
+      }
+
+      const dict: Map<string, IModule> = new Map();
+      for (const alias of collection.aliases())
+        prepare(dict)(alias.name)((importer) =>
+          define_alias(config)(importer)(alias),
+        );
+      for (const object of collection.objects())
+        prepare(dict)(object.name)((importer) =>
+          define_object(config)(importer)(object),
+        );
+      return dict;
+    };
+
+  const prepare =
+    (dict: Map<string, IModule>) =>
+    (name: string) =>
+    (programmer: (importer: ImportDictionary) => ts.TypeAliasDeclaration) => {
+      const accessors: string[] = name.split(".");
+      const modulo: IPointer<IModule> = { value: null! };
+
+      accessors.forEach((acc, i) => {
+        modulo.value = MapUtil.take(dict, acc, () => ({
+          name: acc,
+          children: new Map(),
+          programmer: null,
+        }));
+        if (i === accessors.length - 1) modulo.value.programmer = programmer;
+        dict = modulo.value.children;
+      });
+      return modulo!;
+    };
+
+  const define_alias =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (alias: MetadataAlias): ts.TypeAliasDeclaration =>
+      FormatUtil.description(
+        ts.factory.createTypeAliasDeclaration(
+          [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
+          alias.name.split(".").at(-1)!,
+          [],
+          SdkTypeProgrammer.decode(config)(importer)(alias.value),
+        ),
+        writeComment([])(alias.description, alias.jsDocTags),
+      );
+
+  const define_object =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (object: MetadataObject): ts.TypeAliasDeclaration => {
+      const regular = object.properties.filter((p) => p.key.isSoleLiteral());
+      const dynamic = object.properties.filter((p) => !p.key.isSoleLiteral());
+      return FormatUtil.description(
+        ts.factory.createTypeAliasDeclaration(
+          [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
+          object.name.split(".").at(-1)!,
+          [],
+          regular.length && dynamic.length
+            ? ts.factory.createIntersectionTypeNode([
+                define_regular(config)(importer)(regular),
+                ...dynamic.map(define_dynamic(config)(importer)),
+              ])
+            : dynamic.length
+              ? ts.factory.createIntersectionTypeNode(
+                  dynamic.map(define_dynamic(config)(importer)),
+                )
+              : define_regular(config)(importer)(regular),
+        ),
+        writeComment([])(object.description ?? null, object.jsDocTags),
+      );
+    };
+
+  const define_regular =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (properties: MetadataProperty[]): ts.TypeLiteralNode =>
+      ts.factory.createTypeLiteralNode(
+        properties.map((p) =>
+          FormatUtil.description(
+            ts.factory.createPropertySignature(
+              undefined,
+              Escaper.variable(String(p.key.constants[0].values[0]))
+                ? ts.factory.createIdentifier(
+                    String(p.key.constants[0].values[0]),
+                  )
+                : ts.factory.createStringLiteral(
+                    String(p.key.constants[0].values[0]),
+                  ),
+              p.value.isRequired() === false
+                ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
+                : undefined,
+              SdkTypeProgrammer.decode(config)(importer)(p.value),
+            ),
+            writeComment(p.value.atomics)(p.description, p.jsDocTags),
+          ),
+        ),
+      );
+
+  const define_dynamic =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (property: MetadataProperty): ts.TypeLiteralNode =>
+      ts.factory.createTypeLiteralNode([
+        FormatUtil.description(
+          ts.factory.createIndexSignature(
+            undefined,
+            [
+              ts.factory.createParameterDeclaration(
+                undefined,
+                undefined,
+                ts.factory.createIdentifier("key"),
+                undefined,
+                SdkTypeProgrammer.decode(config)(importer)(property.key),
+              ),
+            ],
+            SdkTypeProgrammer.decode(config)(importer)(property.value),
+          ),
+          writeComment(property.value.atomics)(
+            property.description,
+            property.jsDocTags,
+          ),
+        ),
+      ]);
+}
+
+const writeComment =
+  (atomics: MetadataAtomic[]) =>
+  (description: string | null, jsDocTags: IJsDocTagInfo[]): string => {
+    const lines: string[] = [];
+    if (description?.length)
+      lines.push(...description.split("\n").map((s) => `${s}`));
+
+    const filtered: IJsDocTagInfo[] =
+      !!atomics.length && !!jsDocTags?.length
+        ? jsDocTags.filter(
+            (tag) =>
+              !atomics.some((a) =>
+                a.tags.some((r) => r.some((t) => t.kind === tag.name)),
+              ),
+          )
+        : jsDocTags ?? [];
+
+    if (description?.length && filtered.length) lines.push("");
+    if (filtered.length)
+      lines.push(
+        ...filtered.map((t) =>
+          t.text?.length
+            ? `@${t.name} ${t.text.map((e) => e.text).join("")}`
+            : `@${t.name}`,
+        ),
+      );
+    return lines.join("\n");
+  };

package/src/generates/internal/SdkNamespaceProgrammer.ts

@@ -1,5 +1,6 @@
 import ts from "typescript";
 import typia from "typia";
+import { ExpressionFactory } from "typia/lib/factories/ExpressionFactory";
 import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
 import { LiteralFactory } from "typia/lib/factories/LiteralFactory";
 import { TypeFactory } from "typia/lib/factories/TypeFactory";
@@ -10,13 +11,14 @@ import { IController } from "../../structures/IController";
 import { IRoute } from "../../structures/IRoute";
 import { FormatUtil } from "../../utils/FormatUtil";
 import { ImportDictionary } from "../../utils/ImportDictionary";
-import { SdkDtoGenerator } from "./SdkDtoGenerator";
+import { SdkAliasCollection } from "./SdkAliasCollection";
 import { SdkImportWizard } from "./SdkImportWizard";
 import { SdkSimulationProgrammer } from "./SdkSimulationProgrammer";
-import { SdkTypeDefiner } from "./SdkTypeDefiner";
+import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
 
 export namespace SdkNamespaceProgrammer {
   export const generate =
+    (checker: ts.TypeChecker) =>
     (config: INestiaConfig) =>
     (importer: ImportDictionary) =>
     (
@@ -27,7 +29,7 @@ export namespace SdkNamespaceProgrammer {
         input: IRoute.IParameter | undefined;
       },
     ): ts.ModuleDeclaration => {
-      const types = generate_types(config)(importer)(route, props);
+      const types = generate_types(checker)(config)(importer)(route, props);
       return ts.factory.createModuleDeclaration(
         [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
         ts.factory.createIdentifier(route.name),
@@ -39,7 +41,9 @@ export namespace SdkNamespaceProgrammer {
           generate_path(config)(importer)(route, props),
           ...(config.simulate
             ? [
-                SdkSimulationProgrammer.random(config)(importer)(route),
+                SdkSimulationProgrammer.random(checker)(config)(importer)(
+                  route,
+                ),
                 SdkSimulationProgrammer.simulate(config)(importer)(
                   route,
                   props,
@@ -55,6 +59,7 @@ export namespace SdkNamespaceProgrammer {
     };
 
   const generate_types =
+    (checker: ts.TypeChecker) =>
     (config: INestiaConfig) =>
     (importer: ImportDictionary) =>
     (
@@ -66,26 +71,35 @@ export namespace SdkNamespaceProgrammer {
       },
     ): ts.TypeAliasDeclaration[] => {
       const array: ts.TypeAliasDeclaration[] = [];
-      const declare = (name: string, type: string) =>
+      const declare = (name: string, type: ts.TypeNode) =>
         array.push(
           ts.factory.createTypeAliasDeclaration(
             [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
             name,
             undefined,
-            ts.factory.createTypeReferenceNode(type),
+            type,
           ),
         );
       if (props.headers !== undefined)
         declare(
           "Headers",
-          SdkTypeDefiner.headers(config)(importer)(props.headers),
+          SdkAliasCollection.headers(config)(importer)(props.headers),
         );
       if (props.query !== undefined)
-        declare("Query", SdkTypeDefiner.query(config)(importer)(props.query));
+        declare(
+          "Query",
+          SdkAliasCollection.query(config)(importer)(props.query),
+        );
       if (props.input !== undefined)
-        declare("Input", SdkTypeDefiner.input(config)(importer)(props.input));
+        declare(
+          "Input",
+          SdkAliasCollection.input(config)(importer)(props.input),
+        );
       if (config.propagate === true || route.output.typeName !== "void")
-        declare("Output", SdkTypeDefiner.output(config)(importer)(route));
+        declare(
+          "Output",
+          SdkAliasCollection.output(checker)(config)(importer)(route),
+        );
       return array;
     };
 
@@ -139,7 +153,7 @@ export namespace SdkNamespaceProgrammer {
               ts.factory.createPropertyAssignment(
                 "status",
                 route.status !== undefined
-                  ? ts.factory.createNumericLiteral(route.status)
+                  ? ExpressionFactory.number(route.status)
                   : ts.factory.createNull(),
               ),
               ...(route.output.contentType ===
@@ -198,11 +212,9 @@ export namespace SdkNamespaceProgrammer {
             g.total.map((p) =>
               IdentifierFactory.parameter(
                 p.name,
-                ts.factory.createTypeReferenceNode(
-                  p === props.query
-                    ? `${route.name}.Query`
-                    : getType(config)(importer)(p),
-                ),
+                p === props.query
+                  ? ts.factory.createTypeReferenceNode(`${route.name}.Query`)
+                  : getType(config)(importer)(p),
               ),
             ),
             undefined,
@@ -365,7 +377,7 @@ export namespace SdkNamespaceProgrammer {
             ts.factory.createReturnStatement(
               ts.factory.createConditionalExpression(
                 ts.factory.createStrictEquality(
-                  ts.factory.createNumericLiteral(0),
+                  ExpressionFactory.number(0),
                   IdentifierFactory.access(
                     ts.factory.createIdentifier(variables),
                   )("size"),
@@ -491,5 +503,5 @@ const getType =
   (importer: ImportDictionary) =>
   (p: IRoute.IParameter | IRoute.IOutput) =>
     p.metadata
-      ? SdkDtoGenerator.decode(config)(importer)(p.metadata)
-      : p.typeName;
+      ? SdkTypeProgrammer.decode(config)(importer)(p.metadata)
+      : ts.factory.createTypeReferenceNode(p.typeName);

package/src/generates/internal/SdkRouteProgrammer.ts

@@ -10,6 +10,7 @@ import { SdkNamespaceProgrammer } from "./SdkNamespaceProgrammer";
 
 export namespace SdkRouteProgrammer {
   export const generate =
+    (checker: ts.TypeChecker) =>
     (config: INestiaConfig) =>
     (importer: ImportDictionary) =>
     (route: IRoute): ts.Statement[] => {
@@ -27,7 +28,10 @@ export namespace SdkRouteProgrammer {
           SdkFunctionProgrammer.generate(config)(importer)(route, props),
           describe(route),
         ),
-        SdkNamespaceProgrammer.generate(config)(importer)(route, props),
+        SdkNamespaceProgrammer.generate(checker)(config)(importer)(
+          route,
+          props,
+        ),
       ];
     };
 

package/src/generates/internal/SdkSimulationProgrammer.ts

@@ -1,4 +1,5 @@
 import ts from "typescript";
+import { ExpressionFactory } from "typia/lib/factories/ExpressionFactory";
 import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
 import { LiteralFactory } from "typia/lib/factories/LiteralFactory";
 import { StatementFactory } from "typia/lib/factories/StatementFactory";
@@ -7,12 +8,13 @@ import { TypeFactory } from "typia/lib/factories/TypeFactory";
 import { INestiaConfig } from "../../INestiaConfig";
 import { IRoute } from "../../structures/IRoute";
 import { ImportDictionary } from "../../utils/ImportDictionary";
-import { SdkDtoGenerator } from "./SdkDtoGenerator";
+import { SdkAliasCollection } from "./SdkAliasCollection";
 import { SdkImportWizard } from "./SdkImportWizard";
-import { SdkTypeDefiner } from "./SdkTypeDefiner";
+import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
 
 export namespace SdkSimulationProgrammer {
   export const random =
+    (checker: ts.TypeChecker) =>
     (config: INestiaConfig) =>
     (importer: ImportDictionary) =>
     (route: IRoute): ts.VariableStatement =>
@@ -42,11 +44,7 @@ export namespace SdkSimulationProgrammer {
             IdentifierFactory.access(
               ts.factory.createIdentifier(SdkImportWizard.typia(importer)),
             )("random"),
-            [
-              ts.factory.createTypeReferenceNode(
-                SdkTypeDefiner.responseBody(config)(importer)(route),
-              ),
-            ],
+            [SdkAliasCollection.responseBody(checker)(config)(importer)(route)],
             [ts.factory.createIdentifier("g")],
           ),
         ),
@@ -121,12 +119,12 @@ export namespace SdkSimulationProgrammer {
                   p.optional
                     ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
                     : undefined,
-                  ts.factory.createTypeReferenceNode(
-                    config.primitive !== false &&
-                      (p === props.query || p === props.input)
-                      ? `${route.name}.${p === props.query ? "Query" : "Input"}`
-                      : getTypeName(config)(importer)(p),
-                  ),
+                  config.primitive !== false &&
+                    (p === props.query || p === props.input)
+                    ? ts.factory.createTypeReferenceNode(
+                        `${route.name}.${p === props.query ? "Query" : "Input"}`,
+                      )
+                    : getTypeName(config)(importer)(p),
                 ),
               ),
           ],
@@ -145,7 +143,7 @@ export namespace SdkSimulationProgrammer {
                         ),
                         ts.factory.createPropertyAssignment(
                           "status",
-                          ts.factory.createNumericLiteral(
+                          ExpressionFactory.number(
                             route.status ??
                               (route.method === "POST" ? 201 : 200),
                           ),
@@ -355,5 +353,5 @@ const getTypeName =
   (importer: ImportDictionary) =>
   (p: IRoute.IParameter | IRoute.IOutput) =>
     p.metadata
-      ? SdkDtoGenerator.decode(config)(importer)(p.metadata)
-      : p.typeName;
+      ? SdkTypeProgrammer.decode(config)(importer)(p.metadata)
+      : ts.factory.createTypeReferenceNode(p.typeName);