@nestia/sdk 11.2.1 → 12.0.0-dev.20260521.1

package/src/generates/internal/SdkAliasCollection.ts

@@ -1,5 +1,6 @@
-import { MetadataSchema, TypeFactory } from "@typia/core";
-import ts from "typescript";
+import { Node, SyntaxKind, TypeScriptFactory } from "@nestia/factory";
+import { TypeFactory } from "@nestia/factory";
+import { MetadataSchema, sizeOf } from "../../internal/legacy";
 
 import { INestiaProject } from "../../structures/INestiaProject";
 import { IReflectType } from "../../structures/IReflectType";
@@ -12,8 +13,8 @@ import { SdkHttpParameterProgrammer } from "./SdkHttpParameterProgrammer";
 import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
 
 export namespace SdkAliasCollection {
-  export const name = ({ type }: { type: IReflectType }): ts.TypeNode =>
-    ts.factory.createTypeReferenceNode(
+  export const name = ({ type }: { type: IReflectType }): Node =>
+    TypeScriptFactory.createTypeReferenceNode(
       type.name,
       type.typeArguments
         ? type.typeArguments.map((a) => name({ type: a }))
@@ -29,8 +30,8 @@ export namespace SdkAliasCollection {
   export const httpProps =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute): ts.TypeNode =>
-      ts.factory.createTypeLiteralNode(
+    (route: ITypedHttpRoute): Node =>
+      TypeScriptFactory.createTypeLiteralNode(
         SdkHttpParameterProgrammer.getEntries({
           project,
           importer,
@@ -39,13 +40,13 @@ export namespace SdkAliasCollection {
           prefix: false,
         })
           .map((e) => {
-            const signature: ts.PropertySignature =
-              ts.factory.createPropertySignature(
+            const signature: Node =
+              TypeScriptFactory.createPropertySignature(
                 undefined,
                 e.key,
                 e.required
                   ? undefined
-                  : ts.factory.createToken(ts.SyntaxKind.QuestionToken),
+                  : TypeScriptFactory.createToken(SyntaxKind.QuestionToken),
                 e.type,
               );
             const description: string | null =
@@ -61,7 +62,7 @@ export namespace SdkAliasCollection {
               null;
             return description?.length
               ? [
-                  ts.factory.createIdentifier("\n") as any,
+                  TypeScriptFactory.createIdentifier("\n") as any,
                   FilePrinter.description(signature, description),
                 ]
               : [signature];
@@ -69,10 +70,10 @@ export namespace SdkAliasCollection {
           .flat(),
       );
 
-  export const websocketProps = (route: ITypedWebSocketRoute): ts.TypeNode =>
-    ts.factory.createTypeLiteralNode([
+  export const websocketProps = (route: ITypedWebSocketRoute): Node =>
+    TypeScriptFactory.createTypeLiteralNode([
       ...route.pathParameters.map((p) =>
-        ts.factory.createPropertySignature(
+        TypeScriptFactory.createPropertySignature(
           undefined,
           p.name,
           undefined,
@@ -81,31 +82,31 @@ export namespace SdkAliasCollection {
       ),
       ...(route.query
         ? [
-            ts.factory.createPropertySignature(
+            TypeScriptFactory.createPropertySignature(
               undefined,
               "query",
               undefined,
-              ts.factory.createTypeReferenceNode("Query"),
+              TypeScriptFactory.createTypeReferenceNode("Query"),
             ),
           ]
         : []),
-      ts.factory.createPropertySignature(
+      TypeScriptFactory.createPropertySignature(
         undefined,
         "provider",
         undefined,
-        ts.factory.createTypeReferenceNode("Provider"),
+        TypeScriptFactory.createTypeReferenceNode("Provider"),
       ),
     ]);
 
   export const headers =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (param: ITypedHttpRouteParameter.IHeaders): ts.TypeNode => {
+    (param: ITypedHttpRouteParameter.IHeaders): Node => {
       if (project.config.clone === true)
         return from(project)(importer)(param.metadata);
-      const type: ts.TypeNode = name(param);
+      const type: Node = name(param);
       if (project.config.primitive === false) return type;
-      return ts.factory.createTypeReferenceNode(
+      return TypeScriptFactory.createTypeReferenceNode(
         importer.external({
           file: "typia",
           declaration: true,
@@ -119,12 +120,12 @@ export namespace SdkAliasCollection {
   export const query =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (param: ITypedHttpRouteParameter.IQuery): ts.TypeNode => {
+    (param: ITypedHttpRouteParameter.IQuery): Node => {
       if (project.config.clone === true)
         return from(project)(importer)(param.metadata);
-      const type: ts.TypeNode = name(param);
+      const type: Node = name(param);
       if (project.config.primitive === false) return type;
-      return ts.factory.createTypeReferenceNode(
+      return TypeScriptFactory.createTypeReferenceNode(
         importer.external({
           file: "typia",
           declaration: true,
@@ -138,18 +139,18 @@ export namespace SdkAliasCollection {
   export const body =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (param: ITypedHttpRouteParameter.IBody): ts.TypeNode => {
+    (param: ITypedHttpRouteParameter.IBody): Node => {
       if (project.config.clone === true) {
-        const type: ts.TypeNode = from(project)(importer)(param.metadata);
+        const type: Node = from(project)(importer)(param.metadata);
         return param.contentType === "multipart/form-data"
           ? formDataInput(importer)(type)
           : type;
       }
-      const type: ts.TypeNode = name(param);
+      const type: Node = name(param);
       if (param.contentType === "multipart/form-data")
         return formDataInput(importer)(type);
       else if (project.config.primitive === false) return type;
-      return ts.factory.createTypeReferenceNode(
+      return TypeScriptFactory.createTypeReferenceNode(
         importer.external({
           file: "typia",
           declaration: true,
@@ -166,14 +167,14 @@ export namespace SdkAliasCollection {
   export const response =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute): ts.TypeNode => {
+    (route: ITypedHttpRoute): Node => {
       const schema = (p: { metadata: MetadataSchema; type: IReflectType }) =>
-        p.metadata.size() === 0
+        sizeOf(p.metadata) === 0
           ? TypeFactory.keyword("void")
           : project.config.clone === true
             ? from(project)(importer)(p.metadata)
             : project.config.primitive !== false
-              ? ts.factory.createTypeReferenceNode(
+              ? TypeScriptFactory.createTypeReferenceNode(
                   importer.external({
                     file: "typia",
                     declaration: true,
@@ -201,7 +202,7 @@ export namespace SdkAliasCollection {
           type: schema(value),
         })),
       ];
-      return ts.factory.createTypeReferenceNode(
+      return TypeScriptFactory.createTypeReferenceNode(
         importer.external({
           file: "@nestia/fetcher",
           declaration: true,
@@ -209,11 +210,11 @@ export namespace SdkAliasCollection {
           name: "IPropagation",
         }),
         [
-          ts.factory.createTypeLiteralNode(
+          TypeScriptFactory.createTypeLiteralNode(
             branches.map((b) =>
-              ts.factory.createPropertySignature(
+              TypeScriptFactory.createPropertySignature(
                 undefined,
-                ts.factory.createNumericLiteral(b.status),
+                TypeScriptFactory.createNumericLiteral(b.status),
                 undefined,
                 b.type,
               ),
@@ -221,8 +222,8 @@ export namespace SdkAliasCollection {
           ),
           ...(route.success.status
             ? [
-                ts.factory.createLiteralTypeNode(
-                  ts.factory.createNumericLiteral(route.success.status),
+                TypeScriptFactory.createLiteralTypeNode(
+                  TypeScriptFactory.createNumericLiteral(route.success.status),
                 ),
               ]
             : []),
@@ -233,7 +234,7 @@ export namespace SdkAliasCollection {
   export const responseBody =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute): ts.TypeNode =>
+    (route: ITypedHttpRoute): Node =>
       response({
         ...project,
         config: {
@@ -242,8 +243,8 @@ export namespace SdkAliasCollection {
         },
       })(importer)(route);
 
-  const formDataInput = (importer: ImportDictionary) => (type: ts.TypeNode) =>
-    ts.factory.createTypeReferenceNode(
+  const formDataInput = (importer: ImportDictionary) => (type: Node) =>
+    TypeScriptFactory.createTypeReferenceNode(
       importer.external({
         file: "@nestia/fetcher",
         declaration: true,
@@ -256,5 +257,5 @@ export namespace SdkAliasCollection {
 
 interface IBranch {
   status: string;
-  type: ts.TypeNode;
+  type: Node;
 }

package/src/generates/internal/SdkDistributionComposer.ts

@@ -1,7 +1,6 @@
 import cp from "child_process";
 import fs from "fs";
 import path from "path";
-import typia from "typia";
 
 import { INestiaConfig } from "../../INestiaConfig";
 
@@ -30,11 +29,12 @@ export namespace SdkDistributionComposer {
       await replace({ root, output })(file);
 
     // INSTALL PACKAGES
-    const v: IDependencies = await dependencies();
+    const v: IDependencies = await dependencies({ websocket: props.websocket });
     execute("npm install --save-dev rimraf");
     execute(`npm install --save @nestia/fetcher@${v.version}`);
     execute(`npm install --save typia@${v.typia}`);
-    if (props.websocket) execute(`npm install --save tgrid@${v.tgrid}`);
+    if (props.websocket && v.tgrid !== undefined)
+      execute(`npm install --save tgrid@${v.tgrid}`);
     execute("npx typia setup --manager npm");
 
     exit();
@@ -77,7 +77,9 @@ export namespace SdkDistributionComposer {
       );
     };
 
-  const dependencies = async (): Promise<IDependencies> => {
+  const dependencies = async (opts: {
+    websocket: boolean;
+  }): Promise<IDependencies> => {
     const content: string = await fs.promises.readFile(
       __dirname + "/../../../package.json",
       "utf8",
@@ -87,17 +89,28 @@ export namespace SdkDistributionComposer {
       dependencies: Record<string, string>;
       devDependencies: Record<string, string>;
     } = JSON.parse(content);
-    return typia.assert<IDependencies>({
+    const dependencies: Record<string, string> = {
       ...json.devDependencies,
       ...json.dependencies,
-      version: json.version,
-    });
+    };
+    const required = (key: "version" | "typia"): string => {
+      const value: string | undefined =
+        key === "version" ? json.version : dependencies[key];
+      if (typeof value !== "string" || value.length === 0)
+        throw new Error(`Unable to resolve ${key} version for SDK distribution.`);
+      return value;
+    };
+    return {
+      version: required("version"),
+      typia: required("typia"),
+      tgrid: opts.websocket ? dependencies.tgrid : undefined,
+    };
   };
 }
 
 interface IDependencies {
   version: string;
   typia: string;
-  tgrid: string;
+  tgrid: string | undefined;
 }
 const BUNDLE = __dirname + "/../../../assets/bundle/distribute";

package/src/generates/internal/SdkFileProgrammer.ts

@@ -1,5 +1,5 @@
+import { Node, TypeScriptFactory } from "@nestia/factory";
 import fs from "fs";
-import ts from "typescript";
 
 import { INestiaProject } from "../../structures/INestiaProject";
 import { ITypedApplication } from "../../structures/ITypedApplication";
@@ -54,15 +54,17 @@ export namespace SdkFileProgrammer {
       } catch {}
 
       // ITERATE CHILDREN
-      const statements: ts.Statement[] = [];
+      const statements: Node[] = [];
       for (const [key, value] of directory.children) {
         await iterate(project)(value)(`${outDir}/${key}`);
         statements.push(
-          ts.factory.createExportDeclaration(
+          TypeScriptFactory.createExportDeclaration(
             undefined,
             false,
-            ts.factory.createNamespaceExport(ts.factory.createIdentifier(key)),
-            ts.factory.createStringLiteral(`./${key}/index`),
+            TypeScriptFactory.createNamespaceExport(
+              TypeScriptFactory.createIdentifier(key),
+            ),
+            TypeScriptFactory.createStringLiteral(`./${key}/index`),
             undefined,
           ),
         );

package/src/generates/internal/SdkHttpCloneProgrammer.ts

@@ -1,10 +1,10 @@
+import { Node, SyntaxKind, TypeScriptFactory } from "@nestia/factory";
 import {
   MetadataAliasType,
   MetadataAtomic,
   MetadataObjectType,
-} from "@typia/core";
+} from "../../internal/legacy";
 import { IPointer } from "tstl";
-import ts from "typescript";
 import { IJsDocTagInfo } from "typia";
 
 import { INestiaProject } from "../../structures/INestiaProject";
@@ -21,7 +21,7 @@ export namespace SdkHttpCloneProgrammer {
     children: Map<string, IModule>;
     programmer:
       | null
-      | ((importer: ImportDictionary) => ts.TypeAliasDeclaration);
+      | ((importer: ImportDictionary) => Node);
   }
 
   export const write = (app: ITypedApplication): Map<string, IModule> => {
@@ -47,7 +47,7 @@ export namespace SdkHttpCloneProgrammer {
   const prepare = (props: {
     dict: Map<string, IModule>;
     name: string;
-    programmer: (importer: ImportDictionary) => ts.TypeAliasDeclaration;
+    programmer: (importer: ImportDictionary) => Node;
   }) => {
     let next: Map<string, IModule> = props.dict;
     const accessors: string[] = props.name.split(".");
@@ -69,10 +69,10 @@ export namespace SdkHttpCloneProgrammer {
   const writeAlias =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (alias: MetadataAliasType): ts.TypeAliasDeclaration =>
+    (alias: MetadataAliasType): Node =>
       FilePrinter.description(
-        ts.factory.createTypeAliasDeclaration(
-          [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
+        TypeScriptFactory.createTypeAliasDeclaration(
+          [TypeScriptFactory.createToken(SyntaxKind.ExportKeyword)],
           alias.name.split(".").at(-1)!,
           [],
           SdkTypeProgrammer.write(project)(importer)(alias.value),
@@ -83,10 +83,10 @@ export namespace SdkHttpCloneProgrammer {
   const writeObject =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (object: MetadataObjectType): ts.TypeAliasDeclaration => {
+    (object: MetadataObjectType): Node => {
       return FilePrinter.description(
-        ts.factory.createTypeAliasDeclaration(
-          [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
+        TypeScriptFactory.createTypeAliasDeclaration(
+          [TypeScriptFactory.createToken(SyntaxKind.ExportKeyword)],
           object.name.split(".").at(-1)!,
           [],
           SdkTypeProgrammer.write_object(project)(importer)(object),

package/src/generates/internal/SdkHttpCloneReferencer.ts

@@ -1,4 +1,4 @@
-import { MetadataSchema } from "@typia/core";
+import { MetadataSchema, nameOf } from "../../internal/legacy";
 
 import { IReflectType } from "../../structures/IReflectType";
 import { ITypedApplication } from "../../structures/ITypedApplication";
@@ -63,11 +63,11 @@ export namespace SdkHttpCloneReferencer {
       if (key.length && StringUtil.isImplicit(key) === false)
         p.unique.add(key.split(".")[0]!);
     };
-    for (const alias of p.metadata.aliases) enroll(alias.type.name);
-    for (const array of p.metadata.arrays) enroll(array.type.name);
-    for (const tuple of p.metadata.tuples) enroll(tuple.type.name);
-    for (const object of p.metadata.objects) enroll(object.type.name);
-    p.name(p.metadata.getName());
+    for (const alias of p.metadata.aliases) enroll(alias.type!.name);
+    for (const array of p.metadata.arrays) enroll(array.type!.name);
+    for (const tuple of p.metadata.tuples) enroll(tuple.type!.name);
+    for (const object of p.metadata.objects) enroll(object.type!.name);
+    p.name(nameOf(p.metadata));
   };
 }