@nestia/sdk 3.0.5 → 3.1.0-dev.20240429

package/src/generates/SwaggerGenerator.ts

@@ -8,10 +8,12 @@ import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
 import { JsonApplicationProgrammer } from "typia/lib/programmers/json/JsonApplicationProgrammer";
 
 import { INestiaConfig } from "../INestiaConfig";
-import { IRoute } from "../structures/IRoute";
+import { INestiaProject } from "../structures/INestiaProject";
 import { ISwaggerError } from "../structures/ISwaggerError";
 import { ISwaggerLazyProperty } from "../structures/ISwaggerLazyProperty";
 import { ISwaggerLazySchema } from "../structures/ISwaggerLazySchema";
+import { ITypedHttpRoute } from "../structures/ITypedHttpRoute";
+import { ITypedWebSocketRoute } from "../structures/ITypedWebSocketRoute";
 import { FileRetriever } from "../utils/FileRetriever";
 import { MapUtil } from "../utils/MapUtil";
 import { SwaggerSchemaGenerator } from "./internal/SwaggerSchemaGenerator";
@@ -28,13 +30,18 @@ export namespace SwaggerGenerator {
   }
 
   export const generate =
-    (checker: ts.TypeChecker) =>
-    (config: INestiaConfig.ISwaggerConfig) =>
-    async (routeList: IRoute[]): Promise<void> => {
+    (project: INestiaProject) =>
+    async (
+      routeList: Array<ITypedHttpRoute | ITypedWebSocketRoute>,
+    ): Promise<void> => {
       console.log("Generating Swagger Documents");
 
       // VALIDATE SECURITY
-      validate_security(config)(routeList);
+      const config = project.config.swagger!;
+      const httpRoutes: ITypedHttpRoute[] = routeList.filter(
+        (route): route is ITypedHttpRoute => route.protocol === "http",
+      ) as ITypedHttpRoute[];
+      validate_security(config)(httpRoutes);
 
       // PREPARE ASSETS
       const parsed: path.ParsedPath = path.parse(config.output);
@@ -66,7 +73,7 @@ export namespace SwaggerGenerator {
         Record<string, OpenApi.IOperation>
       > = new Map();
 
-      for (const route of routeList) {
+      for (const route of httpRoutes) {
         if (route.jsDocTags.find((tag) => tag.name === "internal")) continue;
 
         const path: Record<string, OpenApi.IOperation> = MapUtil.take(
@@ -76,7 +83,7 @@ export namespace SwaggerGenerator {
         );
         path[route.method.toLowerCase()] = generate_route({
           config,
-          checker,
+          checker: project.checker,
           collection,
           lazySchemas,
           lazyProperties,
@@ -116,9 +123,9 @@ export namespace SwaggerGenerator {
       if (errors.length) {
         for (const e of errors)
           console.error(
-            `${path.relative(e.route.location, process.cwd())}:${
-              e.route.target.class.name
-            }.${e.route.target.function.name}:${
+            `${path.relative(process.cwd(), e.route.location)}:${
+              e.route.controller.name
+            }.${e.route.name}:${
               e.from
             } - error TS(@nestia/sdk): invalid type detected.\n\n` +
               e.messages.map((m) => `  - ${m}`).join("\n"),
@@ -131,11 +138,11 @@ export namespace SwaggerGenerator {
       const customizer = {
         at: new Singleton(() => {
           const functor: Map<Function, Endpoint> = new Map();
-          for (const route of routeList) {
+          for (const route of httpRoutes) {
             const method: OpenApi.Method =
               route.method.toLowerCase() as OpenApi.Method;
             const path: string = get_path(route.path, route.parameters);
-            functor.set(route.target.function, {
+            functor.set(route.function, {
               method,
               path,
               route: swagger.paths![path][method]!,
@@ -161,13 +168,13 @@ export namespace SwaggerGenerator {
             },
         ),
       };
-      for (const route of routeList) {
+      for (const route of httpRoutes) {
         if (
           false ===
           Reflect.hasMetadata(
             "nestia/SwaggerCustomizer",
             route.controller.prototype,
-            route.target.function.name,
+            route.name,
           )
         )
           continue;
@@ -179,7 +186,7 @@ export namespace SwaggerGenerator {
         const closure: Function | Function[] = Reflect.getMetadata(
           "nestia/SwaggerCustomizer",
           route.controller.prototype,
-          route.target.function.name,
+          route.name,
         );
         const array: Function[] = Array.isArray(closure) ? closure : [closure];
         for (const fn of array)
@@ -209,7 +216,7 @@ export namespace SwaggerGenerator {
 
   const validate_security =
     (config: INestiaConfig.ISwaggerConfig) =>
-    (routeList: IRoute[]): void | never => {
+    (routeList: ITypedHttpRoute[]): void | never => {
       const securityMap: Map<
         string,
         { scheme: OpenApi.ISecurityScheme; scopes: Set<string> }
@@ -252,7 +259,7 @@ export namespace SwaggerGenerator {
           for (const [key, scopes] of Object.entries(record))
             validate((str) =>
               violations.push(
-                `  - ${str} (${route.target.class.name}.${route.target.function.name}() at "${route.location}")`,
+                `  - ${str} (${route.controller.name}.${route.name}() at "${route.location}")`,
               ),
             )(key, scopes);
 
@@ -345,8 +352,11 @@ export namespace SwaggerGenerator {
     };
   };
 
-  function get_path(path: string, parameters: IRoute.IParameter[]): string {
-    const filtered: IRoute.IParameter[] = parameters.filter(
+  function get_path(
+    path: string,
+    parameters: ITypedHttpRoute.IParameter[],
+  ): string {
+    const filtered: ITypedHttpRoute.IParameter[] = parameters.filter(
       (param) => param.category === "param" && !!param.field,
     );
     for (const param of filtered)
@@ -356,7 +366,7 @@ export namespace SwaggerGenerator {
 
   const generate_route =
     (props: IProps) =>
-    (route: IRoute): OpenApi.IOperation => {
+    (route: ITypedHttpRoute): OpenApi.IOperation => {
       // FIND REQUEST BODY
       const body = route.parameters.find((param) => param.category === "body");
 
@@ -414,8 +424,8 @@ export namespace SwaggerGenerator {
         operationId:
           route.operationId ??
           props.config.operationId?.({
-            class: route.target.class.name,
-            function: route.target.function.name,
+            class: route.controller.name,
+            function: route.name,
             method: route.method as "GET",
             path: route.path,
           }),

package/src/generates/internal/E2eFileProgrammer.ts

@@ -1,8 +1,8 @@
 import ts from "typescript";
 import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
 
-import { INestiaConfig } from "../../INestiaConfig";
-import { IRoute } from "../../structures/IRoute";
+import { INestiaProject } from "../../structures/INestiaProject";
+import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
 import { FilePrinter } from "./FilePrinter";
 import { ImportDictionary } from "./ImportDictionary";
 import { SdkAliasCollection } from "./SdkAliasCollection";
@@ -11,14 +11,13 @@ import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
 
 export namespace E2eFileProgrammer {
   export const generate =
-    (checker: ts.TypeChecker) =>
-    (config: INestiaConfig) =>
+    (project: INestiaProject) =>
     (props: { api: string; current: string }) =>
-    async (route: IRoute): Promise<void> => {
+    async (route: ITypedHttpRoute): Promise<void> => {
       const importer: ImportDictionary = new ImportDictionary(
         `${props.current}/${getFunctionName(route)}.ts`,
       );
-      if (config.clone !== true)
+      if (project.config.clone !== true)
         for (const tuple of route.imports)
           for (const instance of tuple[1])
             importer.internal({
@@ -33,7 +32,7 @@ export namespace E2eFileProgrammer {
         name: "api",
       });
 
-      const functor = generate_function(checker)(config)(importer)(route);
+      const functor = generate_function(project)(importer)(route);
       await FilePrinter.write({
         location: importer.file,
         statements: [
@@ -45,10 +44,9 @@ export namespace E2eFileProgrammer {
     };
 
   const generate_function =
-    (checker: ts.TypeChecker) =>
-    (config: INestiaConfig) =>
+    (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: IRoute): ts.Statement =>
+    (route: ITypedHttpRoute): ts.Statement =>
       ts.factory.createVariableStatement(
         [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
         ts.factory.createVariableDeclarationList(
@@ -57,7 +55,7 @@ export namespace E2eFileProgrammer {
               ts.factory.createIdentifier(getFunctionName(route)),
               undefined,
               undefined,
-              generate_arrow(checker)(config)(importer)(route),
+              generate_arrow(project)(importer)(route),
             ),
           ],
           ts.NodeFlags.Const,
@@ -65,10 +63,9 @@ export namespace E2eFileProgrammer {
       );
 
   const generate_arrow =
-    (checker: ts.TypeChecker) =>
-    (config: INestiaConfig) =>
+    (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: IRoute) => {
+    (route: ITypedHttpRoute) => {
       const headers = route.parameters.find(
         (p) => p.category === "headers" && p.field === undefined,
       );
@@ -94,7 +91,7 @@ export namespace E2eFileProgrammer {
                             SdkImportWizard.typia(importer),
                           ),
                         )("random"),
-                        [getTypeName(config)(importer)(headers)],
+                        [getTypeName(project)(importer)(headers)],
                         undefined,
                       ),
                     ),
@@ -120,7 +117,7 @@ export namespace E2eFileProgrammer {
                 IdentifierFactory.access(
                   ts.factory.createIdentifier(SdkImportWizard.typia(importer)),
                 )("random"),
-                [getTypeName(config)(importer)(p)],
+                [getTypeName(project)(importer)(p)],
                 undefined,
               ),
             ),
@@ -153,11 +150,10 @@ export namespace E2eFileProgrammer {
                 ts.factory.createVariableDeclaration(
                   "output",
                   undefined,
-                  config.propagate !== true && route.output.typeName === "void"
+                  project.config.propagate !== true &&
+                    route.output.typeName === "void"
                     ? undefined
-                    : SdkAliasCollection.output(checker)(config)(importer)(
-                        route,
-                      ),
+                    : SdkAliasCollection.output(project)(importer)(route),
                   ts.factory.createAwaitExpression(caller),
                 ),
               ],
@@ -170,13 +166,13 @@ export namespace E2eFileProgrammer {
     };
 }
 
-const getFunctionName = (route: IRoute): string =>
+const getFunctionName = (route: ITypedHttpRoute): string =>
   ["test", "api", ...route.accessors].join("_");
 
 const getTypeName =
-  (config: INestiaConfig) =>
+  (project: INestiaProject) =>
   (importer: ImportDictionary) =>
-  (p: IRoute.IParameter | IRoute.IOutput) =>
+  (p: ITypedHttpRoute.IParameter | ITypedHttpRoute.IOutput) =>
     p.metadata
-      ? SdkTypeProgrammer.write(config)(importer)(p.metadata)
+      ? SdkTypeProgrammer.write(project)(importer)(p.metadata)
       : ts.factory.createTypeReferenceNode(p.typeName);

package/src/generates/internal/SdkAliasCollection.ts

@@ -1,27 +1,27 @@
 import ts from "typescript";
 import typia from "typia";
 
-import { INestiaConfig } from "../../INestiaConfig";
-import { IController } from "../../structures/IController";
-import { IRoute } from "../../structures/IRoute";
+import { INestiaProject } from "../../structures/INestiaProject";
+import { IReflectHttpOperation } from "../../structures/IReflectHttpOperation";
+import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
 import { ImportDictionary } from "./ImportDictionary";
 import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
 
 export namespace SdkAliasCollection {
   export const name =
-    (config: INestiaConfig) =>
+    (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (p: IRoute.IParameter | IRoute.IOutput): ts.TypeNode =>
+    (p: ITypedHttpRoute.IParameter | ITypedHttpRoute.IOutput): ts.TypeNode =>
       p.metadata
-        ? SdkTypeProgrammer.write(config)(importer)(p.metadata)
+        ? SdkTypeProgrammer.write(project)(importer)(p.metadata)
         : ts.factory.createTypeReferenceNode(p.typeName);
 
   export const headers =
-    (config: INestiaConfig) =>
+    (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (param: IRoute.IParameter): ts.TypeNode => {
-      const type: ts.TypeNode = name(config)(importer)(param);
-      if (config.primitive === false) return type;
+    (param: ITypedHttpRoute.IParameter): ts.TypeNode => {
+      const type: ts.TypeNode = name(project)(importer)(param);
+      if (project.config.primitive === false) return type;
       return ts.factory.createTypeReferenceNode(
         importer.external({
           type: true,
@@ -33,11 +33,11 @@ export namespace SdkAliasCollection {
     };
 
   export const query =
-    (config: INestiaConfig) =>
+    (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (param: IRoute.IParameter): ts.TypeNode => {
-      const type: ts.TypeNode = name(config)(importer)(param);
-      if (config.primitive === false) return type;
+    (param: ITypedHttpRoute.IParameter): ts.TypeNode => {
+      const type: ts.TypeNode = name(project)(importer)(param);
+      if (project.config.primitive === false) return type;
       return ts.factory.createTypeReferenceNode(
         importer.external({
           type: true,
@@ -49,17 +49,18 @@ export namespace SdkAliasCollection {
     };
 
   export const input =
-    (config: INestiaConfig) =>
+    (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (param: IRoute.IParameter): ts.TypeNode => {
-      const type: ts.TypeNode = name(config)(importer)(param);
-      if (config.clone === true || config.primitive === false) return type;
+    (param: ITypedHttpRoute.IParameter): ts.TypeNode => {
+      const type: ts.TypeNode = name(project)(importer)(param);
+      if (project.config.clone === true || project.config.primitive === false)
+        return type;
       return ts.factory.createTypeReferenceNode(
         importer.external({
           type: true,
           library: "@nestia/fetcher",
           instance:
-            typia.is<IController.IBodyParameter>(param) &&
+            typia.is<IReflectHttpOperation.IBodyParameter>(param) &&
             param.contentType === "multipart/form-data"
               ? "Resolved"
               : "Primitive",
@@ -69,18 +70,17 @@ export namespace SdkAliasCollection {
     };
 
   export const output =
-    (checker: ts.TypeChecker) =>
-    (config: INestiaConfig) =>
+    (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: IRoute): ts.TypeNode => {
-      if (config.propagate !== true) {
-        const node: ts.TypeNode = name(config)(importer)(route.output);
-        const type = checker.getTypeAtLocation(node);
+    (route: ITypedHttpRoute): ts.TypeNode => {
+      if (project.config.propagate !== true) {
+        const node: ts.TypeNode = name(project)(importer)(route.output);
+        const type = project.checker.getTypeAtLocation(node);
         const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
 
         if (
-          config.clone === true ||
-          config.primitive === false ||
+          project.config.clone === true ||
+          project.config.primitive === false ||
           filter(ts.TypeFlags.Undefined) ||
           filter(ts.TypeFlags.Never) ||
           filter(ts.TypeFlags.Void) ||
@@ -103,11 +103,11 @@ export namespace SdkAliasCollection {
       const branches: IBranch[] = [
         {
           status: String(route.status ?? (route.method === "POST" ? 201 : 200)),
-          type: name(config)(importer)(route.output),
+          type: name(project)(importer)(route.output),
         },
         ...Object.entries(route.exceptions).map(([status, value]) => ({
           status,
-          type: name(config)(importer)(value),
+          type: name(project)(importer)(value),
         })),
       ];
       return ts.factory.createTypeReferenceNode(
@@ -139,11 +139,16 @@ export namespace SdkAliasCollection {
     };
 
   export const responseBody =
-    (checker: ts.TypeChecker) =>
-    (config: INestiaConfig) =>
+    (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: IRoute): ts.TypeNode =>
-      output(checker)({ ...config, propagate: false })(importer)(route);
+    (route: ITypedHttpRoute): ts.TypeNode =>
+      output({
+        ...project,
+        config: {
+          ...project.config,
+          propagate: false,
+        },
+      })(importer)(route);
 }
 
 interface IBranch {

package/src/generates/internal/SdkDistributionComposer.ts

@@ -1,11 +1,12 @@
 import cp from "child_process";
 import fs from "fs";
 import path from "path";
+import typia from "typia";
 
 import { INestiaConfig } from "../../INestiaConfig";
 
 export namespace SdkDistributionComposer {
-  export const compose = async (config: INestiaConfig) => {
+  export const compose = async (config: INestiaConfig, websocket: boolean) => {
     if (!fs.existsSync(config.distribute!))
       await fs.promises.mkdir(config.distribute!);
 
@@ -32,6 +33,7 @@ export namespace SdkDistributionComposer {
       `npm install --save @nestia/fetcher@${versions["@nestia/fetcher"]}`,
     );
     execute(`npm install --save typia@${versions["typia"]}`);
+    if (websocket) execute(`npm install --save tgrid@${versions["tgrid"]}`);
     execute("npx typia setup --manager npm");
 
     exit();
@@ -74,18 +76,25 @@ export namespace SdkDistributionComposer {
       );
     };
 
-  const dependencies = async () => {
+  const dependencies = async (): Promise<IDependencies> => {
     const content: string = await fs.promises.readFile(
       __dirname + "/../../../package.json",
       "utf8",
     );
-    const json: { dependencies: IDependencies } = JSON.parse(content);
-    return json.dependencies;
+    const json: {
+      dependencies: Record<string, string>;
+      devDependencies: Record<string, string>;
+    } = JSON.parse(content);
+    return typia.assert<IDependencies>({
+      ...json.devDependencies,
+      ...json.dependencies,
+    });
   };
 }
 
 interface IDependencies {
   "@nestia/fetcher": string;
   typia: string;
+  tgrid: string;
 }
 const BUNDLE = __dirname + "/../../../assets/bundle/distribute";

package/src/generates/internal/SdkFileProgrammer.ts

@@ -1,33 +1,36 @@
 import fs from "fs";
 import ts from "typescript";
 
-import { INestiaConfig } from "../../INestiaConfig";
-import { IRoute } from "../../structures/IRoute";
+import { INestiaProject } from "../../structures/INestiaProject";
+import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
+import { ITypedWebSocketRoute } from "../../structures/ITypedWebSocketRoute";
 import { MapUtil } from "../../utils/MapUtil";
 import { FilePrinter } from "./FilePrinter";
 import { ImportDictionary } from "./ImportDictionary";
+import { SdkHttpRouteProgrammer } from "./SdkHttpRouteProgrammer";
 import { SdkRouteDirectory } from "./SdkRouteDirectory";
-import { SdkRouteProgrammer } from "./SdkRouteProgrammer";
+import { SdkWebSocketRouteProgrammer } from "./SdkWebSocketRouteProgrammer";
 
 export namespace SdkFileProgrammer {
   /* ---------------------------------------------------------
         CONSTRUCTOR
     --------------------------------------------------------- */
   export const generate =
-    (checker: ts.TypeChecker) =>
-    (config: INestiaConfig) =>
-    async (routeList: IRoute[]): Promise<void> => {
+    (project: INestiaProject) =>
+    async (
+      routeList: Array<ITypedHttpRoute | ITypedWebSocketRoute>,
+    ): Promise<void> => {
       // CONSTRUCT FOLDER TREE
       const root: SdkRouteDirectory = new SdkRouteDirectory(null, "functional");
       for (const route of routeList) emplace(root)(route);
 
       // ITERATE FILES
-      await iterate(checker)(config)(root)(config.output + "/functional");
+      await iterate(project)(root)(project.config.output + "/functional");
     };
 
   const emplace =
     (directory: SdkRouteDirectory) =>
-    (route: IRoute): void => {
+    (route: ITypedHttpRoute | ITypedWebSocketRoute): void => {
       // OPEN DIRECTORIES
       for (const key of route.accessors.slice(0, -1)) {
         directory = MapUtil.take(
@@ -45,8 +48,7 @@ export namespace SdkFileProgrammer {
         FILE ITERATOR
     --------------------------------------------------------- */
   const iterate =
-    (checker: ts.TypeChecker) =>
-    (config: INestiaConfig) =>
+    (project: INestiaProject) =>
     (directory: SdkRouteDirectory) =>
     async (outDir: string): Promise<void> => {
       // CREATE A NEW DIRECTORY
@@ -57,7 +59,7 @@ export namespace SdkFileProgrammer {
       // ITERATE CHILDREN
       const statements: ts.Statement[] = [];
       for (const [key, value] of directory.children) {
-        await iterate(checker)(config)(value)(`${outDir}/${key}`);
+        await iterate(project)(value)(`${outDir}/${key}`);
         statements.push(
           ts.factory.createExportDeclaration(
             undefined,
@@ -76,7 +78,7 @@ export namespace SdkFileProgrammer {
         `${outDir}/index.ts`,
       );
       directory.routes.forEach((route, i) => {
-        if (config.clone !== true)
+        if (project.config.clone !== true)
           for (const tuple of route.imports)
             for (const instance of tuple[1])
               importer.internal({
@@ -85,7 +87,9 @@ export namespace SdkFileProgrammer {
                 type: true,
               });
         statements.push(
-          ...SdkRouteProgrammer.generate(checker)(config)(importer)(route),
+          ...(route.protocol === "http"
+            ? SdkHttpRouteProgrammer.write(project)(importer)(route)
+            : SdkWebSocketRouteProgrammer.write(project)(importer)(route)),
         );
         if (i !== directory.routes.length - 1)
           statements.push(FilePrinter.enter());

package/src/generates/internal/{SdkCloneProgrammer.ts → SdkHttpCloneProgrammer.ts}

@@ -7,14 +7,14 @@ 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 { INestiaConfig } from "../../INestiaConfig";
-import { IRoute } from "../../structures/IRoute";
+import { INestiaProject } from "../../structures/INestiaProject";
+import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
 import { MapUtil } from "../../utils/MapUtil";
 import { FilePrinter } from "./FilePrinter";
 import { ImportDictionary } from "./ImportDictionary";
 import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
 
-export namespace SdkCloneProgrammer {
+export namespace SdkHttpCloneProgrammer {
   export interface IModule {
     name: string;
     children: Map<string, IModule>;
@@ -24,15 +24,14 @@ export namespace SdkCloneProgrammer {
   }
 
   export const write =
-    (checker: ts.TypeChecker) =>
-    (config: INestiaConfig) =>
-    (routes: IRoute[]): Map<string, IModule> => {
+    (project: INestiaProject) =>
+    (routes: ITypedHttpRoute[]): 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)({
+          const res = MetadataFactory.analyze(project.checker)({
             escape: false,
             constant: true,
             absorb: false,
@@ -40,14 +39,14 @@ export namespace SdkCloneProgrammer {
           if (res.success) p.metadata = res.data;
         }
         for (const e of Object.values(r.exceptions)) {
-          const res = MetadataFactory.analyze(checker)({
+          const res = MetadataFactory.analyze(project.checker)({
             escape: true,
             constant: true,
             absorb: false,
           })(collection)(e.type);
           if (res.success) e.metadata = res.data;
         }
-        const res = MetadataFactory.analyze(checker)({
+        const res = MetadataFactory.analyze(project.checker)({
           escape: true,
           constant: true,
           absorb: false,
@@ -59,12 +58,12 @@ export namespace SdkCloneProgrammer {
       for (const alias of collection.aliases())
         if (isNamedDeclaration(alias.name))
           prepare(dict)(alias.name)((importer) =>
-            write_alias(config)(importer)(alias),
+            write_alias(project)(importer)(alias),
           );
       for (const object of collection.objects())
         if (isNamedDeclaration(object.name))
           prepare(dict)(object.name)((importer) =>
-            write_object(config)(importer)(object),
+            write_object(project)(importer)(object),
           );
       return dict;
     };
@@ -89,7 +88,7 @@ export namespace SdkCloneProgrammer {
     };
 
   const write_alias =
-    (config: INestiaConfig) =>
+    (project: INestiaProject) =>
     (importer: ImportDictionary) =>
     (alias: MetadataAlias): ts.TypeAliasDeclaration =>
       FilePrinter.description(
@@ -97,13 +96,13 @@ export namespace SdkCloneProgrammer {
           [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
           alias.name.split(".").at(-1)!,
           [],
-          SdkTypeProgrammer.write(config)(importer)(alias.value),
+          SdkTypeProgrammer.write(project)(importer)(alias.value),
         ),
         writeComment([])(alias.description, alias.jsDocTags),
       );
 
   const write_object =
-    (config: INestiaConfig) =>
+    (project: INestiaProject) =>
     (importer: ImportDictionary) =>
     (object: MetadataObject): ts.TypeAliasDeclaration => {
       return FilePrinter.description(
@@ -111,7 +110,7 @@ export namespace SdkCloneProgrammer {
           [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
           object.name.split(".").at(-1)!,
           [],
-          SdkTypeProgrammer.write_object(config)(importer)(object),
+          SdkTypeProgrammer.write_object(project)(importer)(object),
         ),
         writeComment([])(object.description ?? null, object.jsDocTags),
       );