@nestia/sdk 13.0.4 → 14.0.1

package/src/generates/internal/SdkFileProgrammer.ts

@@ -1,4 +1,4 @@
-import { type Node, factory } from "@ttsc/factory";
+import { type Node, SyntaxKind, factory } from "@ttsc/factory";
 import fs from "fs";
 
 import { INestiaProject } from "../../structures/INestiaProject";
@@ -7,6 +7,7 @@ import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
 import { ITypedMcpRoute } from "../../structures/ITypedMcpRoute";
 import { ITypedWebSocketRoute } from "../../structures/ITypedWebSocketRoute";
 import { MapUtil } from "../../utils/MapUtil";
+import { StringUtil } from "../../utils/StringUtil";
 import { FilePrinter } from "./FilePrinter";
 import { ImportDictionary } from "./ImportDictionary";
 import { SdkHttpRouteProgrammer } from "./SdkHttpRouteProgrammer";
@@ -70,22 +71,75 @@ export namespace SdkFileProgrammer {
         statements.push(FilePrinter.enter());
 
       // ITERATE ROUTES
-      const importer: ImportDictionary = new ImportDictionary(
-        `${outDir}/index.ts`,
-      );
-      directory.routes.forEach((route, i) => {
-        if (!(project.config.clone === true && route.protocol === "http"))
-          importer.declarations(route.imports);
-        statements.push(
-          ...(route.protocol === "http"
-            ? SdkHttpRouteProgrammer.write(project)(importer)(route)
-            : route.protocol === "websocket"
-              ? SdkWebSocketRouteProgrammer.write(project)(importer)(route)
-              : SdkMcpRouteProgrammer.write(project)(importer)(route)),
+      const write = (locals: Map<AnyRoute, string>) => {
+        const importer: ImportDictionary = new ImportDictionary(
+          `${outDir}/index.ts`,
         );
-        if (i !== directory.routes.length - 1)
-          statements.push(FilePrinter.enter());
-      });
+        const output: Node[] = [];
+        directory.routes.forEach((route, i) => {
+          if (!(project.config.clone === true && route.protocol === "http"))
+            importer.declarations(route.imports);
+          const local: string | undefined = locals.get(route);
+          const target: AnyRoute =
+            local === undefined ? route : { ...route, name: local };
+          const written: Node[] =
+            target.protocol === "http"
+              ? SdkHttpRouteProgrammer.write(project)(importer)(target)
+              : target.protocol === "websocket"
+                ? SdkWebSocketRouteProgrammer.write(project)(importer)(target)
+                : SdkMcpRouteProgrammer.write(project)(importer)(target);
+          if (local !== undefined) {
+            written.forEach(unexport);
+            written.push(
+              factory.createExportDeclaration(
+                undefined,
+                false,
+                factory.createNamedExports([
+                  factory.createExportSpecifier(false, local, route.name),
+                ]),
+                undefined,
+              ),
+            );
+          }
+          output.push(...written);
+          if (i !== directory.routes.length - 1)
+            output.push(FilePrinter.enter());
+        });
+        return { importer, statements: output };
+      };
+
+      // A route's function and namespace are declared in the module scope,
+      // where the file's imports and the globals its bodies reference live
+      // too. A route named like one of them shadows it for the whole file, or
+      // conflicts with the import, so the SDK would not compile (#1647); a
+      // method named `tags` whose path parameter is typed with `tags.Format`
+      // is enough. Its public name cannot change, so it is declared under a
+      // local one and exported as itself.
+      let file = write(new Map());
+      const scope: Set<string> = new Set([
+        ...file.importer.locals(),
+        ...MODULE_GLOBALS,
+      ]);
+      const shadowing: AnyRoute[] = directory.routes.filter((r) =>
+        scope.has(r.name),
+      );
+      if (shadowing.length !== 0) {
+        // each local name distinct from the scope, the routes, and the other
+        // locals
+        const taken: string[] = [
+          ...scope,
+          ...directory.routes.map((r) => r.name),
+        ];
+        const locals: Map<AnyRoute, string> = new Map();
+        for (const route of shadowing) {
+          const local: string = StringUtil.escapeDuplicate(taken)(route.name);
+          taken.push(local);
+          locals.set(route, local);
+        }
+        file = write(locals);
+      }
+      const importer: ImportDictionary = file.importer;
+      statements.push(...file.statements);
 
       // FINALIZE THE CONTENT
       if (directory.routes.length !== 0)
@@ -109,3 +163,41 @@ export namespace SdkFileProgrammer {
       });
     };
 }
+
+type AnyRoute = ITypedHttpRoute | ITypedWebSocketRoute | ITypedMcpRoute;
+
+/**
+ * Globals the generated route bodies reference, and names TypeScript reserves
+ * in a module's top-level scope: `Promise` in one with async functions, and
+ * `require` and `exports` in a CommonJS one.
+ */
+const MODULE_GLOBALS: string[] = [
+  "Array",
+  "Error",
+  "JSON",
+  "Object",
+  "Promise",
+  "ReadableStream",
+  "String",
+  "URLSearchParams",
+  "encodeURIComponent",
+  "exports",
+  "require",
+  "undefined",
+];
+
+/** Drops the `export` modifier of a route's function or namespace. */
+const unexport = (node: Node): void => {
+  const declaration = node as {
+    kind: string;
+    modifiers?: Array<{ kind: string; token?: string }>;
+  };
+  if (
+    (declaration.kind === "FunctionDeclaration" ||
+      declaration.kind === "ModuleDeclaration") &&
+    declaration.modifiers !== undefined
+  )
+    declaration.modifiers = declaration.modifiers.filter(
+      (m) => m.token !== SyntaxKind.ExportKeyword,
+    );
+};

package/src/generates/internal/SdkHttpFunctionProgrammer.ts

@@ -15,7 +15,6 @@ import { TypeFactory } from "../../factories/TypeFactory";
 import { sizeOf } from "../../internal/legacy";
 import { INestiaProject } from "../../structures/INestiaProject";
 import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
-import { StringUtil } from "../../utils/StringUtil";
 import { ImportDictionary } from "./ImportDictionary";
 import { SdkAliasCollection } from "./SdkAliasCollection";
 import { SdkHttpParameterProgrammer } from "./SdkHttpParameterProgrammer";
@@ -26,6 +25,8 @@ export namespace SdkHttpFunctionProgrammer {
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
     (route: ITypedHttpRoute): Node => {
+      const names: SdkHttpParameterProgrammer.INames =
+        SdkHttpParameterProgrammer.getNames({ project, route });
       return factory.createFunctionDeclaration(
         [
           factory.createModifier(SyntaxKind.ExportKeyword),
@@ -36,7 +37,7 @@ export namespace SdkHttpFunctionProgrammer {
         undefined,
         [
           IdentifierFactory.parameter(
-            "connection",
+            names.connection,
             factory.createTypeReferenceNode(
               SdkImportWizard.IConnection(importer),
               route.headerObject !== null
@@ -59,21 +60,15 @@ export namespace SdkHttpFunctionProgrammer {
             ? factory.createTypeReferenceNode(`${route.name}.Output`)
             : factory.createTypeReferenceNode("void"),
         ]),
-        factory.createBlock(writeBody(project)(importer)(route), true),
+        factory.createBlock(writeBody(project)(importer)(route)(names), true),
       );
     };
 
   const writeBody =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute): Statement[] => {
-      const access = (name: string): Expression =>
-        project.config.keyword === true
-          ? factory.createPropertyAccessExpression(
-              factory.createIdentifier("props"),
-              name,
-            )
-          : factory.createIdentifier(name);
+    (route: ITypedHttpRoute) =>
+    (names: SdkHttpParameterProgrammer.INames): Statement[] => {
       const fetch = () =>
         factory.createCallExpression(
           IdentifierFactory.access(
@@ -95,7 +90,7 @@ export namespace SdkHttpFunctionProgrammer {
               ? factory.createObjectLiteralExpression(
                   [
                     factory.createSpreadAssignment(
-                      factory.createIdentifier("connection"),
+                      factory.createIdentifier(names.connection),
                     ),
                     factory.createPropertyAssignment(
                       "headers",
@@ -103,7 +98,7 @@ export namespace SdkHttpFunctionProgrammer {
                         [
                           factory.createSpreadAssignment(
                             IdentifierFactory.access(
-                              factory.createIdentifier("connection"),
+                              factory.createIdentifier(names.connection),
                               "headers",
                             ),
                           ),
@@ -120,7 +115,7 @@ export namespace SdkHttpFunctionProgrammer {
                   ],
                   true,
                 )
-              : factory.createIdentifier("connection"),
+              : factory.createIdentifier(names.connection),
             factory.createObjectLiteralExpression(
               [
                 factory.createSpreadAssignment(
@@ -157,7 +152,7 @@ export namespace SdkHttpFunctionProgrammer {
               ],
               true,
             ),
-            ...(route.body ? [access(route.body.name)] : []),
+            ...(route.body ? [names.access(route.body)] : []),
             ...(project.config.json &&
             route.body !== null &&
             (route.body.contentType === "application/json" ||
@@ -171,14 +166,17 @@ export namespace SdkHttpFunctionProgrammer {
           ? factory.createConditionalExpression(
               factory.createStrictEquality(
                 factory.createTrue(),
-                factory.createIdentifier("connection.simulate"),
+                IdentifierFactory.access(
+                  factory.createIdentifier(names.connection),
+                  "simulate",
+                ),
               ),
               undefined,
               factory.createCallExpression(
                 factory.createIdentifier(`${route.name}.simulate`),
                 [],
                 [
-                  factory.createIdentifier("connection"),
+                  factory.createIdentifier(names.connection),
                   ...(SdkHttpParameterProgrammer.getArguments({
                     project,
                     route,
@@ -201,15 +199,15 @@ export namespace SdkHttpFunctionProgrammer {
                     factory.createIdentifier(SdkImportWizard.typia(importer)),
                     "assert",
                   ),
-                  [factory.createTypeQueryNode(access(p.name) as EntityName)],
-                  [access(p.name)],
+                  [factory.createTypeQueryNode(names.access(p) as EntityName)],
+                  [names.access(p)],
                 ),
               ),
             )
           : []),
         ...(route.success.setHeaders.length === 0
           ? [factory.createReturnStatement(output(false))]
-          : writeSetHeaders(project)(importer)(route)(output(true))),
+          : writeSetHeaders(project)(importer)(route)(names)(output(true))),
       ];
     };
 
@@ -217,16 +215,12 @@ export namespace SdkHttpFunctionProgrammer {
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
     (route: ITypedHttpRoute) =>
+    (names: SdkHttpParameterProgrammer.INames) =>
     (condition: Expression): Statement[] => {
       const accessor = (x: string) => (y: string) =>
         x[0] === "[" ? `${x}${y}` : `${x}.${y}`;
-      const output: string = StringUtil.escapeDuplicate([
-        "connection",
-        ...SdkHttpParameterProgrammer.getSignificant(route, true).map(
-          (p) => p.name,
-        ),
-      ])("output");
-      const headers: string = accessor("connection")("headers");
+      const output: string = names.output;
+      const headers: string = accessor(names.connection)("headers");
       const data: string = project.config.propagate
         ? accessor(output)("data")
         : output;
@@ -248,9 +242,13 @@ export namespace SdkHttpFunctionProgrammer {
                 ],
               )
             : factory.createBinaryExpression(
-                factory.createIdentifier(
-                  accessor(headers)(tuple.target ?? tuple.source),
-                ),
+                // a target is a header name, which usually is no identifier
+                tuple.target !== undefined
+                  ? IdentifierFactory.access(
+                      factory.createIdentifier(headers),
+                      tuple.target,
+                    )
+                  : factory.createIdentifier(accessor(headers)(tuple.source)),
                 factory.createToken(SyntaxKind.EqualsToken),
                 factory.createIdentifier(accessor(data)(tuple.source)),
               ),

package/src/generates/internal/SdkHttpNamespaceProgrammer.ts

@@ -24,6 +24,7 @@ import { SdkAliasCollection } from "./SdkAliasCollection";
 import { SdkHttpParameterProgrammer } from "./SdkHttpParameterProgrammer";
 import { SdkHttpSimulationProgrammer } from "./SdkHttpSimulationProgrammer";
 import { SdkImportWizard } from "./SdkImportWizard";
+import { SdkPathTemplate } from "./SdkPathTemplate";
 
 export namespace SdkHttpNamespaceProgrammer {
   export const write =
@@ -210,59 +211,28 @@ export namespace SdkHttpNamespaceProgrammer {
         false,
       );
       if (parameters.length === 0)
-        return out(factory.createStringLiteral(route.path));
-
-      const access = (name: string) =>
-        project.config.keyword === true ? `props.${name}` : name;
-      const template = () => {
-        const split: string[] = route.path.split(":");
-        if (split.length === 1) return factory.createStringLiteral(route.path);
-        return factory.createTemplateExpression(
-          factory.createTemplateHead(split[0]!),
-          split.slice(1).map((s, i, arr) => {
-            const name: string = s.split("/")[0]!;
-            return factory.createTemplateSpan(
-              factory.createCallExpression(
-                factory.createIdentifier("encodeURIComponent"),
-                undefined,
-                [
-                  factory.createBinaryExpression(
-                    factory.createCallChain(
-                      factory.createPropertyAccessChain(
-                        factory.createIdentifier(
-                          access(
-                            route.pathParameters.find((p) => p.field === name)!
-                              .name,
-                          ),
-                        ),
-                        factory.createToken(SyntaxKind.QuestionDotToken),
-                        "toString",
-                      ),
-                      undefined,
-                      undefined,
-                      [],
-                    ),
-                    factory.createToken(SyntaxKind.QuestionQuestionToken),
-                    factory.createStringLiteral("null"),
-                  ),
-                ],
-              ),
-              (i !== arr.length - 1
-                ? factory.createTemplateMiddle
-                : factory.createTemplateTail)(s.substring(name.length)),
-            );
+        return out(
+          SdkPathTemplate.compose({
+            importer,
+            path: route.path,
+            argument: () => factory.createIdentifier("undefined"),
           }),
         );
-      };
+
+      const names: SdkHttpParameterProgrammer.INames =
+        SdkHttpParameterProgrammer.getNames({ project, route });
+      const template = () =>
+        SdkPathTemplate.compose({
+          importer,
+          path: route.path,
+          argument: (name) =>
+            names.access(route.pathParameters.find((p) => p.field === name)!),
+        });
       if (route.queryObject === null && route.queryParameters.length === 0)
         return out(template());
 
       const block = (expr: Expression) => {
-        const computeName = (str: string): string =>
-          parameters.find((p) => p.name === str) !== undefined
-            ? computeName("_" + str)
-            : str;
-        const variables: string = computeName("variables");
+        const variables: string = names.variables;
         return factory.createBlock(
           [
             local(variables)("URLSearchParams")(
@@ -281,13 +251,13 @@ export namespace SdkHttpNamespaceProgrammer {
                       factory.createBindingElement(
                         undefined,
                         undefined,
-                        factory.createIdentifier("key"),
+                        factory.createIdentifier(names.key),
                         undefined,
                       ),
                       factory.createBindingElement(
                         undefined,
                         undefined,
-                        factory.createIdentifier("value"),
+                        factory.createIdentifier(names.value),
                         undefined,
                       ),
                     ]),
@@ -306,19 +276,19 @@ export namespace SdkHttpNamespaceProgrammer {
               factory.createIfStatement(
                 factory.createStrictEquality(
                   factory.createIdentifier("undefined"),
-                  factory.createIdentifier("value"),
+                  factory.createIdentifier(names.value),
                 ),
                 factory.createContinueStatement(),
                 factory.createIfStatement(
                   factory.createCallExpression(
                     factory.createIdentifier("Array.isArray"),
                     undefined,
-                    [factory.createIdentifier("value")],
+                    [factory.createIdentifier(names.value)],
                   ),
                   factory.createExpressionStatement(
                     factory.createCallExpression(
                       factory.createPropertyAccessExpression(
-                        factory.createIdentifier("value"),
+                        factory.createIdentifier(names.value),
                         factory.createIdentifier("forEach"),
                       ),
                       undefined,
@@ -326,7 +296,7 @@ export namespace SdkHttpNamespaceProgrammer {
                         factory.createArrowFunction(
                           undefined,
                           undefined,
-                          [IdentifierFactory.parameter("elem")],
+                          [IdentifierFactory.parameter(names.elem)],
                           undefined,
                           undefined,
                           factory.createCallExpression(
@@ -336,11 +306,11 @@ export namespace SdkHttpNamespaceProgrammer {
                             ),
                             undefined,
                             [
-                              factory.createIdentifier("key"),
+                              factory.createIdentifier(names.key),
                               factory.createCallExpression(
                                 factory.createIdentifier("String"),
                                 undefined,
-                                [factory.createIdentifier("elem")],
+                                [factory.createIdentifier(names.elem)],
                               ),
                             ],
                           ),
@@ -356,11 +326,11 @@ export namespace SdkHttpNamespaceProgrammer {
                       ),
                       undefined,
                       [
-                        factory.createIdentifier("key"),
+                        factory.createIdentifier(names.key),
                         factory.createCallExpression(
                           factory.createIdentifier("String"),
                           undefined,
-                          [factory.createIdentifier("value")],
+                          [factory.createIdentifier(names.value)],
                         ),
                       ],
                     ),
@@ -368,7 +338,7 @@ export namespace SdkHttpNamespaceProgrammer {
                 ),
               ),
             ),
-            local("location")("string")(template()),
+            local(names.location)("string")(template()),
             factory.createReturnStatement(
               factory.createConditionalExpression(
                 factory.createStrictEquality(
@@ -379,13 +349,13 @@ export namespace SdkHttpNamespaceProgrammer {
                   ),
                 ),
                 undefined,
-                factory.createIdentifier("location"),
+                factory.createIdentifier(names.location),
                 undefined,
                 factory.createTemplateExpression(
                   factory.createTemplateHead(""),
                   [
                     factory.createTemplateSpan(
-                      factory.createIdentifier("location"),
+                      factory.createIdentifier(names.location),
                       factory.createTemplateMiddle("?"),
                     ),
                     factory.createTemplateSpan(
@@ -412,11 +382,11 @@ export namespace SdkHttpNamespaceProgrammer {
           block(
             route.queryObject.metadata.required === false
               ? factory.createBinaryExpression(
-                  factory.createIdentifier(route.queryObject.name),
+                  names.access(route.queryObject),
                   factory.createToken(SyntaxKind.QuestionQuestionToken),
                   factory.createObjectLiteralExpression([], false),
                 )
-              : factory.createIdentifier(access(route.queryObject.name)),
+              : names.access(route.queryObject),
           ),
         );
       return out(
@@ -426,7 +396,7 @@ export namespace SdkHttpNamespaceProgrammer {
               ...(route.queryObject
                 ? [
                     factory.createSpreadAssignment(
-                      factory.createIdentifier(access(route.queryObject.name)),
+                      names.access(route.queryObject),
                     ),
                   ]
                 : []),
@@ -435,7 +405,7 @@ export namespace SdkHttpNamespaceProgrammer {
                   NamingConvention.variable(q.field!)
                     ? q.field!
                     : factory.createStringLiteral(q.field!),
-                  factory.createIdentifier(access(q.name)),
+                  names.access(q),
                 ),
               ),
             ],