@nestia/core 10.0.2 → 11.0.0-dev.20260312

package/src/programmers/TypedQueryRouteProgrammer.ts

@@ -1,102 +1,104 @@
-import ts from "typescript";
-import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
-import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
-import { HttpQueryProgrammer } from "typia/lib/programmers/http/HttpQueryProgrammer";
-import { LlmSchemaProgrammer } from "typia/lib/programmers/llm/LlmSchemaProgrammer";
-import { Metadata } from "typia/lib/schemas/metadata/Metadata";
-import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
-import { TransformerError } from "typia/lib/transformers/TransformerError";
-import { ValidationPipe } from "typia/lib/typings/ValidationPipe";
-
-import { INestiaTransformOptions } from "../options/INestiaTransformOptions";
-import { INestiaTransformContext } from "../options/INestiaTransformProject";
-import { HttpAssertQuerifyProgrammer } from "./http/HttpAssertQuerifyProgrammer";
-import { HttpIsQuerifyProgrammer } from "./http/HttpIsQuerifyProgrammer";
-import { HttpQuerifyProgrammer } from "./http/HttpQuerifyProgrammer";
-import { HttpValidateQuerifyProgrammer } from "./http/HttpValidateQuerifyProgrammer";
-
-export namespace TypedQueryRouteProgrammer {
-  export const generate = (props: {
-    context: INestiaTransformContext;
-    modulo: ts.LeftHandSideExpression;
-    type: ts.Type;
-  }): ts.Expression => {
-    // VALIDATE TYPE
-    if (props.context.options.llm) {
-      const llm: INestiaTransformOptions.ILlm = props.context.options.llm;
-      const result: ValidationPipe<Metadata, MetadataFactory.IError> =
-        MetadataFactory.analyze({
-          checker: props.context.checker,
-          transformer: props.context.transformer,
-          options: {
-            escape: false,
-            constant: true,
-            absorb: true,
-            validate: (meta, explore) => {
-              const errors: string[] = HttpQueryProgrammer.validate(
-                meta,
-                explore,
-                true,
-              );
-              errors.push(
-                ...LlmSchemaProgrammer.validate({
-                  config: {
-                    strict: llm.strict,
-                  },
-                  metadata: meta,
-                }),
-              );
-              return errors;
-            },
-          },
-          collection: new MetadataCollection(),
-          type: props.type,
-        });
-      if (result.success === false)
-        throw TransformerError.from({
-          code: props.modulo.getText(),
-          errors: result.errors,
-        });
-    }
-
-    // GENERATE STRINGIFY PLAN
-    const parameter = (
-      key: string,
-      programmer: (next: {
-        context: ITypiaContext;
-        modulo: ts.LeftHandSideExpression;
-        type: ts.Type;
-      }) => ts.ArrowFunction,
-    ) =>
-      ts.factory.createObjectLiteralExpression([
-        ts.factory.createPropertyAssignment(
-          ts.factory.createIdentifier("type"),
-          ts.factory.createStringLiteral(key),
-        ),
-        ts.factory.createPropertyAssignment(
-          ts.factory.createIdentifier(key),
-          programmer({
-            context: {
-              ...props.context,
-              options: {}, // use default option
-            },
-            modulo: props.modulo,
-            type: props.type,
-          }),
-        ),
-      ]);
-
-    // RETURNS
-    if (props.context.options.stringify === "is")
-      return parameter("is", HttpIsQuerifyProgrammer.write);
-    else if (props.context.options.stringify === "validate")
-      return parameter("validate", HttpValidateQuerifyProgrammer.write);
-    else if (props.context.options.stringify === "stringify")
-      return parameter("stringify", HttpQuerifyProgrammer.write);
-    else if (props.context.options.stringify === null)
-      return ts.factory.createNull();
-
-    // ASSERT IS DEFAULT
-    return parameter("assert", HttpAssertQuerifyProgrammer.write);
-  };
-}
+import {
+  HttpQueryProgrammer,
+  ITypiaContext,
+  LlmSchemaProgrammer,
+  MetadataCollection,
+  MetadataFactory,
+  MetadataSchema,
+  TransformerError,
+} from "@typia/core";
+import { ValidationPipe } from "@typia/interface";
+import ts from "typescript";
+
+import { INestiaTransformOptions } from "../options/INestiaTransformOptions";
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
+import { HttpAssertQuerifyProgrammer } from "./http/HttpAssertQuerifyProgrammer";
+import { HttpIsQuerifyProgrammer } from "./http/HttpIsQuerifyProgrammer";
+import { HttpQuerifyProgrammer } from "./http/HttpQuerifyProgrammer";
+import { HttpValidateQuerifyProgrammer } from "./http/HttpValidateQuerifyProgrammer";
+
+export namespace TypedQueryRouteProgrammer {
+  export const generate = (props: {
+    context: INestiaTransformContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.Expression => {
+    // VALIDATE TYPE
+    if (props.context.options.llm) {
+      const llm: INestiaTransformOptions.ILlm = props.context.options.llm;
+      const result: ValidationPipe<MetadataSchema, MetadataFactory.IError> =
+        MetadataFactory.analyze({
+          checker: props.context.checker,
+          transformer: props.context.transformer,
+          options: {
+            escape: false,
+            constant: true,
+            absorb: true,
+            validate: (meta, explore) => {
+              const errors: string[] = HttpQueryProgrammer.validate(
+                meta,
+                explore,
+                true,
+              );
+              errors.push(
+                ...LlmSchemaProgrammer.validate({
+                  config: {
+                    strict: llm.strict ?? false,
+                  },
+                  metadata: meta,
+                }),
+              );
+              return errors;
+            },
+          },
+          components: new MetadataCollection(),
+          type: props.type,
+        });
+      if (result.success === false)
+        throw TransformerError.from({
+          code: props.modulo.getText(),
+          errors: result.errors,
+        });
+    }
+
+    // GENERATE STRINGIFY PLAN
+    const parameter = (
+      key: string,
+      programmer: (next: {
+        context: ITypiaContext;
+        modulo: ts.LeftHandSideExpression;
+        type: ts.Type;
+      }) => ts.ArrowFunction,
+    ) =>
+      ts.factory.createObjectLiteralExpression([
+        ts.factory.createPropertyAssignment(
+          ts.factory.createIdentifier("type"),
+          ts.factory.createStringLiteral(key),
+        ),
+        ts.factory.createPropertyAssignment(
+          ts.factory.createIdentifier(key),
+          programmer({
+            context: {
+              ...props.context,
+              options: {}, // use default option
+            },
+            modulo: props.modulo,
+            type: props.type,
+          }),
+        ),
+      ]);
+
+    // RETURNS
+    if (props.context.options.stringify === "is")
+      return parameter("is", HttpIsQuerifyProgrammer.write);
+    else if (props.context.options.stringify === "validate")
+      return parameter("validate", HttpValidateQuerifyProgrammer.write);
+    else if (props.context.options.stringify === "stringify")
+      return parameter("stringify", HttpQuerifyProgrammer.write);
+    else if (props.context.options.stringify === null)
+      return ts.factory.createNull();
+
+    // ASSERT IS DEFAULT
+    return parameter("assert", HttpAssertQuerifyProgrammer.write);
+  };
+}

package/src/programmers/TypedRouteProgrammer.ts

@@ -1,94 +1,96 @@
-import ts from "typescript";
-import { JsonMetadataFactory } from "typia/lib/factories/JsonMetadataFactory";
-import { JsonAssertStringifyProgrammer } from "typia/lib/programmers/json/JsonAssertStringifyProgrammer";
-import { JsonIsStringifyProgrammer } from "typia/lib/programmers/json/JsonIsStringifyProgrammer";
-import { JsonStringifyProgrammer } from "typia/lib/programmers/json/JsonStringifyProgrammer";
-import { JsonValidateStringifyProgrammer } from "typia/lib/programmers/json/JsonValidateStringifyProgrammer";
-import { LlmSchemaProgrammer } from "typia/lib/programmers/llm/LlmSchemaProgrammer";
-import { IProgrammerProps } from "typia/lib/transformers/IProgrammerProps";
-
-import { INestiaTransformContext } from "../options/INestiaTransformProject";
-
-export namespace TypedRouteProgrammer {
-  export const generate = (props: {
-    context: INestiaTransformContext;
-    modulo: ts.LeftHandSideExpression;
-    type: ts.Type;
-  }): ts.Expression => {
-    // VALIDATE TYPE
-    if (props.context.options.llm)
-      JsonMetadataFactory.analyze({
-        method: "@nestia.core.TypedRoute",
-        checker: props.context.checker,
-        transformer: props.context.transformer,
-        type: props.type,
-        validate: (metadata) =>
-          LlmSchemaProgrammer.validate({
-            config: {
-              strict: props.context.options.llm?.strict,
-            },
-            metadata,
-          }),
-      });
-
-    // GENERATE STRINGIFY PLAN
-    const parameter = (next: {
-      type: string;
-      key: string;
-      programmer: (next: IProgrammerProps) => ts.Expression;
-    }) =>
-      ts.factory.createObjectLiteralExpression([
-        ts.factory.createPropertyAssignment(
-          ts.factory.createIdentifier("type"),
-          ts.factory.createStringLiteral(next.type),
-        ),
-        ts.factory.createPropertyAssignment(
-          ts.factory.createIdentifier(next.key),
-          next.programmer({
-            context: {
-              ...props.context,
-              options: {}, // use default option
-            },
-            modulo: props.modulo,
-            type: props.type,
-            name: undefined,
-          }),
-        ),
-      ]);
-
-    // RETURNS
-    if (props.context.options.stringify === "is")
-      return parameter({
-        type: "is",
-        key: "is",
-        programmer: JsonIsStringifyProgrammer.write,
-      });
-    else if (props.context.options.stringify === "validate")
-      return parameter({
-        type: "validate",
-        key: "validate",
-        programmer: JsonValidateStringifyProgrammer.write,
-      });
-    else if (props.context.options.stringify === "stringify")
-      return parameter({
-        type: "stringify",
-        key: "stringify",
-        programmer: JsonStringifyProgrammer.write,
-      });
-    else if (props.context.options.stringify === "validate.log")
-      return parameter({
-        type: "validate.log",
-        key: "validate",
-        programmer: JsonValidateStringifyProgrammer.write,
-      });
-    else if (props.context.options.stringify === null)
-      return ts.factory.createNull();
-
-    // ASSERT IS DEFAULT
-    return parameter({
-      type: "assert",
-      key: "assert",
-      programmer: JsonAssertStringifyProgrammer.write,
-    });
-  };
-}
+import {
+  IProgrammerProps,
+  JsonAssertStringifyProgrammer,
+  JsonIsStringifyProgrammer,
+  JsonMetadataFactory,
+  JsonStringifyProgrammer,
+  JsonValidateStringifyProgrammer,
+  LlmSchemaProgrammer,
+} from "@typia/core";
+import ts from "typescript";
+
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
+
+export namespace TypedRouteProgrammer {
+  export const generate = (props: {
+    context: INestiaTransformContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.Expression => {
+    // VALIDATE TYPE
+    if (props.context.options.llm)
+      JsonMetadataFactory.analyze({
+        method: "@nestia.core.TypedRoute",
+        checker: props.context.checker,
+        transformer: props.context.transformer,
+        type: props.type,
+        validate: (metadata) =>
+          LlmSchemaProgrammer.validate({
+            config: {
+              strict: props.context.options.llm?.strict ?? false,
+            },
+            metadata,
+          }),
+      });
+
+    // GENERATE STRINGIFY PLAN
+    const parameter = (next: {
+      type: string;
+      key: string;
+      programmer: (next: IProgrammerProps) => ts.Expression;
+    }) =>
+      ts.factory.createObjectLiteralExpression([
+        ts.factory.createPropertyAssignment(
+          ts.factory.createIdentifier("type"),
+          ts.factory.createStringLiteral(next.type),
+        ),
+        ts.factory.createPropertyAssignment(
+          ts.factory.createIdentifier(next.key),
+          next.programmer({
+            context: {
+              ...props.context,
+              options: {}, // use default option
+            },
+            modulo: props.modulo,
+            type: props.type,
+            name: undefined,
+          }),
+        ),
+      ]);
+
+    // RETURNS
+    if (props.context.options.stringify === "is")
+      return parameter({
+        type: "is",
+        key: "is",
+        programmer: JsonIsStringifyProgrammer.write,
+      });
+    else if (props.context.options.stringify === "validate")
+      return parameter({
+        type: "validate",
+        key: "validate",
+        programmer: JsonValidateStringifyProgrammer.write,
+      });
+    else if (props.context.options.stringify === "stringify")
+      return parameter({
+        type: "stringify",
+        key: "stringify",
+        programmer: JsonStringifyProgrammer.write,
+      });
+    else if (props.context.options.stringify === "validate.log")
+      return parameter({
+        type: "validate.log",
+        key: "validate",
+        programmer: JsonValidateStringifyProgrammer.write,
+      });
+    else if (props.context.options.stringify === null)
+      return ts.factory.createNull();
+
+    // ASSERT IS DEFAULT
+    return parameter({
+      type: "assert",
+      key: "assert",
+      programmer: JsonAssertStringifyProgrammer.write,
+    });
+  };
+}

package/src/programmers/http/HttpAssertQuerifyProgrammer.ts

@@ -1,72 +1,74 @@
-import ts from "typescript";
-import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
-import { StatementFactory } from "typia/lib/factories/StatementFactory";
-import { AssertProgrammer } from "typia/lib/programmers/AssertProgrammer";
-import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
-
-import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
-
-export namespace HttpAssertQuerifyProgrammer {
-  export const write = (props: {
-    context: ITypiaContext;
-    modulo: ts.LeftHandSideExpression;
-    type: ts.Type;
-  }): ts.ArrowFunction =>
-    ts.factory.createArrowFunction(
-      undefined,
-      undefined,
-      [IdentifierFactory.parameter("input")],
-      undefined,
-      undefined,
-      ts.factory.createBlock([
-        StatementFactory.constant({
-          name: "assert",
-          value: AssertProgrammer.write({
-            context: {
-              ...props.context,
-              options: {
-                ...props.context.options,
-                functional: false,
-                numeric: false,
-              },
-            },
-            modulo: props.modulo,
-            config: {
-              equals: false,
-              guard: false,
-            },
-            type: props.type,
-            name: undefined,
-          }),
-        }),
-        StatementFactory.constant({
-          name: "stringify",
-          value: HttpQuerifyProgrammer.write({
-            context: {
-              ...props.context,
-              options: {
-                ...props.context.options,
-                functional: false,
-                numeric: false,
-              },
-            },
-            modulo: props.modulo,
-            type: props.type,
-          }),
-        }),
-        ts.factory.createReturnStatement(
-          ts.factory.createCallExpression(
-            ts.factory.createIdentifier("stringify"),
-            undefined,
-            [
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("assert"),
-                undefined,
-                [ts.factory.createIdentifier("input")],
-              ),
-            ],
-          ),
-        ),
-      ]),
-    );
-}
+import {
+  AssertProgrammer,
+  ITypiaContext,
+  IdentifierFactory,
+  StatementFactory,
+} from "@typia/core";
+import ts from "typescript";
+
+import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
+
+export namespace HttpAssertQuerifyProgrammer {
+  export const write = (props: {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.ArrowFunction =>
+    ts.factory.createArrowFunction(
+      undefined,
+      undefined,
+      [IdentifierFactory.parameter("input")],
+      undefined,
+      undefined,
+      ts.factory.createBlock([
+        StatementFactory.constant({
+          name: "assert",
+          value: AssertProgrammer.write({
+            context: {
+              ...props.context,
+              options: {
+                ...props.context.options,
+                functional: false,
+                numeric: false,
+              },
+            },
+            modulo: props.modulo,
+            config: {
+              equals: false,
+              guard: false,
+            },
+            type: props.type,
+            name: undefined,
+          }),
+        }),
+        StatementFactory.constant({
+          name: "stringify",
+          value: HttpQuerifyProgrammer.write({
+            context: {
+              ...props.context,
+              options: {
+                ...props.context.options,
+                functional: false,
+                numeric: false,
+              },
+            },
+            modulo: props.modulo,
+            type: props.type,
+          }),
+        }),
+        ts.factory.createReturnStatement(
+          ts.factory.createCallExpression(
+            ts.factory.createIdentifier("stringify"),
+            undefined,
+            [
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("assert"),
+                undefined,
+                [ts.factory.createIdentifier("input")],
+              ),
+            ],
+          ),
+        ),
+      ]),
+    );
+}