@nestia/core 7.0.0-dev.20250607 → 7.0.0

package/src/programmers/PlainBodyProgrammer.ts

@@ -1,70 +1,70 @@
-import ts from "typescript";
-import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
-import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
-import { AssertProgrammer } from "typia/lib/programmers/AssertProgrammer";
-import { Metadata } from "typia/lib/schemas/metadata/Metadata";
-import { TransformerError } from "typia/lib/transformers/TransformerError";
-
-import { INestiaTransformContext } from "../options/INestiaTransformProject";
-
-export namespace PlainBodyProgrammer {
-  export const generate = (props: {
-    context: INestiaTransformContext;
-    modulo: ts.LeftHandSideExpression;
-    type: ts.Type;
-  }): ts.Expression => {
-    const result = MetadataFactory.analyze({
-      checker: props.context.checker,
-      transformer: props.context.transformer,
-      options: {
-        escape: false,
-        constant: true,
-        absorb: true,
-        validate,
-      },
-      collection: new MetadataCollection(),
-      type: props.type,
-    });
-    if (result.success === false)
-      throw TransformerError.from({
-        code: "nestia.core.TypedParam",
-        errors: result.errors,
-      });
-    return AssertProgrammer.write({
-      context: {
-        ...props.context,
-        options: {
-          numeric: false,
-          finite: false,
-          functional: false,
-        },
-      },
-      modulo: props.modulo,
-      config: {
-        equals: false,
-        guard: false,
-      },
-      type: props.type,
-      name: undefined,
-    });
-  };
-}
-
-const validate = (metadata: Metadata): string[] => {
-  const errors: string[] = [];
-  const insert = (msg: string) => errors.push(msg);
-
-  const expected: number =
-    (metadata.atomics.some((a) => a.type === "string") ? 1 : 0) +
-    metadata.templates.length +
-    metadata.constants
-      .filter((c) => c.type === "string")
-      .map((c) => c.values.length)
-      .reduce((a, b) => a + b, 0);
-  if (expected === 0 || expected !== metadata.size())
-    insert(`only string type is allowed`);
-  if (metadata.nullable === true) insert(`do not allow nullable type`);
-  else if (metadata.any === true) insert(`do not allow any type`);
-
-  return errors;
-};
+import ts from "typescript";
+import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
+import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
+import { AssertProgrammer } from "typia/lib/programmers/AssertProgrammer";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+import { TransformerError } from "typia/lib/transformers/TransformerError";
+
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
+
+export namespace PlainBodyProgrammer {
+  export const generate = (props: {
+    context: INestiaTransformContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.Expression => {
+    const result = MetadataFactory.analyze({
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      options: {
+        escape: false,
+        constant: true,
+        absorb: true,
+        validate,
+      },
+      collection: new MetadataCollection(),
+      type: props.type,
+    });
+    if (result.success === false)
+      throw TransformerError.from({
+        code: "nestia.core.TypedParam",
+        errors: result.errors,
+      });
+    return AssertProgrammer.write({
+      context: {
+        ...props.context,
+        options: {
+          numeric: false,
+          finite: false,
+          functional: false,
+        },
+      },
+      modulo: props.modulo,
+      config: {
+        equals: false,
+        guard: false,
+      },
+      type: props.type,
+      name: undefined,
+    });
+  };
+}
+
+const validate = (metadata: Metadata): string[] => {
+  const errors: string[] = [];
+  const insert = (msg: string) => errors.push(msg);
+
+  const expected: number =
+    (metadata.atomics.some((a) => a.type === "string") ? 1 : 0) +
+    metadata.templates.length +
+    metadata.constants
+      .filter((c) => c.type === "string")
+      .map((c) => c.values.length)
+      .reduce((a, b) => a + b, 0);
+  if (expected === 0 || expected !== metadata.size())
+    insert(`only string type is allowed`);
+  if (metadata.nullable === true) insert(`do not allow nullable type`);
+  else if (metadata.any === true) insert(`do not allow any type`);
+
+  return errors;
+};

package/src/programmers/TypedBodyProgrammer.ts

@@ -1,142 +1,142 @@
-import ts from "typescript";
-import { JsonMetadataFactory } from "typia/lib/factories/JsonMetadataFactory";
-import { AssertProgrammer } from "typia/lib/programmers/AssertProgrammer";
-import { IsProgrammer } from "typia/lib/programmers/IsProgrammer";
-import { ValidateProgrammer } from "typia/lib/programmers/ValidateProgrammer";
-import { LlmSchemaProgrammer } from "typia/lib/programmers/llm/LlmSchemaProgrammer";
-import { MiscAssertCloneProgrammer } from "typia/lib/programmers/misc/MiscAssertCloneProgrammer";
-import { MiscAssertPruneProgrammer } from "typia/lib/programmers/misc/MiscAssertPruneProgrammer";
-import { MiscValidateCloneProgrammer } from "typia/lib/programmers/misc/MiscValidateCloneProgrammer";
-import { MiscValidatePruneProgrammer } from "typia/lib/programmers/misc/MiscValidatePruneProgrammer";
-import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
-
-import { INestiaTransformContext } from "../options/INestiaTransformProject";
-import { IRequestBodyValidator } from "../options/IRequestBodyValidator";
-
-export namespace TypedBodyProgrammer {
-  export const generate = (props: {
-    context: INestiaTransformContext;
-    modulo: ts.LeftHandSideExpression;
-    type: ts.Type;
-  }): ts.ObjectLiteralExpression => {
-    // VALIDATE TYPE
-    JsonMetadataFactory.analyze({
-      method: "@nestia.core.TypedBody",
-      checker: props.context.checker,
-      transformer: props.context.transformer,
-      type: props.type,
-      validate: props.context.options.llm
-        ? LlmSchemaProgrammer.validate({
-            model: props.context.options.llm.model,
-            config: {
-              strict: props.context.options.llm.strict,
-              recursive: props.context.options.llm.recursive,
-            },
-          })
-        : undefined,
-    });
-
-    // GENERATE VALIDATION PLAN
-    const check =
-      (key: IRequestBodyValidator<any>["type"]) =>
-      (equals: boolean) =>
-      (
-        programmer: (next: {
-          context: ITypiaContext;
-          modulo: ts.LeftHandSideExpression;
-          config: {
-            equals: boolean;
-            guard: boolean;
-          };
-          type: ts.Type;
-          name: string | undefined;
-        }) => ts.Expression,
-      ) =>
-        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: {
-                  numeric: false,
-                  finite: false,
-                  functional: false,
-                },
-              },
-              modulo: props.modulo,
-              config: {
-                equals,
-                guard: false,
-              },
-              type: props.type,
-              name: undefined,
-            }),
-          ),
-        ]);
-    const misc =
-      (key: IRequestBodyValidator<any>["type"]) =>
-      (
-        programmer: (next: {
-          context: ITypiaContext;
-          modulo: ts.LeftHandSideExpression;
-          type: ts.Type;
-          name: string | undefined;
-        }) => ts.Expression,
-      ) =>
-        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: {
-                  numeric: false,
-                  finite: false,
-                  functional: false,
-                },
-              },
-              modulo: props.modulo,
-              type: props.type,
-              name: undefined,
-            }),
-          ),
-        ]);
-
-    //----
-    // RETURNS
-    //----
-    const category = props.context.options.validate;
-    // NORMAL
-    if (category === "assert")
-      return check("assert")(false)(AssertProgrammer.write);
-    else if (category === "is") return check("is")(false)(IsProgrammer.write);
-    // STRICT
-    else if (category === "validateEquals")
-      return check("validate")(true)(ValidateProgrammer.write);
-    else if (category === "equals")
-      return check("is")(true)(IsProgrammer.write);
-    else if (category === "assertEquals")
-      return check("assert")(true)(AssertProgrammer.write);
-    // CLONE
-    else if (category === "assertClone")
-      return misc("assert")(MiscAssertCloneProgrammer.write);
-    else if (category === "validateClone")
-      return misc("validate")(MiscValidateCloneProgrammer.write);
-    // PRUNE
-    else if (category === "assertPrune")
-      return misc("assert")(MiscAssertPruneProgrammer.write);
-    else if (category === "validatePrune")
-      return misc("validate")(MiscValidatePruneProgrammer.write);
-    // DEFAULT
-    return check("validate")(false)(ValidateProgrammer.write);
-  };
-}
+import ts from "typescript";
+import { JsonMetadataFactory } from "typia/lib/factories/JsonMetadataFactory";
+import { AssertProgrammer } from "typia/lib/programmers/AssertProgrammer";
+import { IsProgrammer } from "typia/lib/programmers/IsProgrammer";
+import { ValidateProgrammer } from "typia/lib/programmers/ValidateProgrammer";
+import { LlmSchemaProgrammer } from "typia/lib/programmers/llm/LlmSchemaProgrammer";
+import { MiscAssertCloneProgrammer } from "typia/lib/programmers/misc/MiscAssertCloneProgrammer";
+import { MiscAssertPruneProgrammer } from "typia/lib/programmers/misc/MiscAssertPruneProgrammer";
+import { MiscValidateCloneProgrammer } from "typia/lib/programmers/misc/MiscValidateCloneProgrammer";
+import { MiscValidatePruneProgrammer } from "typia/lib/programmers/misc/MiscValidatePruneProgrammer";
+import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
+
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
+import { IRequestBodyValidator } from "../options/IRequestBodyValidator";
+
+export namespace TypedBodyProgrammer {
+  export const generate = (props: {
+    context: INestiaTransformContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.ObjectLiteralExpression => {
+    // VALIDATE TYPE
+    JsonMetadataFactory.analyze({
+      method: "@nestia.core.TypedBody",
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      type: props.type,
+      validate: props.context.options.llm
+        ? LlmSchemaProgrammer.validate({
+            model: props.context.options.llm.model,
+            config: {
+              strict: props.context.options.llm.strict,
+              recursive: props.context.options.llm.recursive,
+            },
+          })
+        : undefined,
+    });
+
+    // GENERATE VALIDATION PLAN
+    const check =
+      (key: IRequestBodyValidator<any>["type"]) =>
+      (equals: boolean) =>
+      (
+        programmer: (next: {
+          context: ITypiaContext;
+          modulo: ts.LeftHandSideExpression;
+          config: {
+            equals: boolean;
+            guard: boolean;
+          };
+          type: ts.Type;
+          name: string | undefined;
+        }) => ts.Expression,
+      ) =>
+        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: {
+                  numeric: false,
+                  finite: false,
+                  functional: false,
+                },
+              },
+              modulo: props.modulo,
+              config: {
+                equals,
+                guard: false,
+              },
+              type: props.type,
+              name: undefined,
+            }),
+          ),
+        ]);
+    const misc =
+      (key: IRequestBodyValidator<any>["type"]) =>
+      (
+        programmer: (next: {
+          context: ITypiaContext;
+          modulo: ts.LeftHandSideExpression;
+          type: ts.Type;
+          name: string | undefined;
+        }) => ts.Expression,
+      ) =>
+        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: {
+                  numeric: false,
+                  finite: false,
+                  functional: false,
+                },
+              },
+              modulo: props.modulo,
+              type: props.type,
+              name: undefined,
+            }),
+          ),
+        ]);
+
+    //----
+    // RETURNS
+    //----
+    const category = props.context.options.validate;
+    // NORMAL
+    if (category === "assert")
+      return check("assert")(false)(AssertProgrammer.write);
+    else if (category === "is") return check("is")(false)(IsProgrammer.write);
+    // STRICT
+    else if (category === "validateEquals")
+      return check("validate")(true)(ValidateProgrammer.write);
+    else if (category === "equals")
+      return check("is")(true)(IsProgrammer.write);
+    else if (category === "assertEquals")
+      return check("assert")(true)(AssertProgrammer.write);
+    // CLONE
+    else if (category === "assertClone")
+      return misc("assert")(MiscAssertCloneProgrammer.write);
+    else if (category === "validateClone")
+      return misc("validate")(MiscValidateCloneProgrammer.write);
+    // PRUNE
+    else if (category === "assertPrune")
+      return misc("assert")(MiscAssertPruneProgrammer.write);
+    else if (category === "validatePrune")
+      return misc("validate")(MiscValidatePruneProgrammer.write);
+    // DEFAULT
+    return check("validate")(false)(ValidateProgrammer.write);
+  };
+}

package/src/programmers/TypedFormDataBodyProgrammer.ts

@@ -1,118 +1,118 @@
-import ts from "typescript";
-import { LiteralFactory } from "typia/lib/factories/LiteralFactory";
-import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
-import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
-import { HttpAssertFormDataProgrammer } from "typia/lib/programmers/http/HttpAssertFormDataProgrammer";
-import { HttpFormDataProgrammer } from "typia/lib/programmers/http/HttpFormDataProgrammer";
-import { HttpIsFormDataProgrammer } from "typia/lib/programmers/http/HttpIsFormDataProgrammer";
-import { HttpValidateFormDataProgrammer } from "typia/lib/programmers/http/HttpValidateFormDataProgrammer";
-import { Metadata } from "typia/lib/schemas/metadata/Metadata";
-import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
-import { TransformerError } from "typia/lib/transformers/TransformerError";
-
-import { INestiaTransformContext } from "../options/INestiaTransformProject";
-import { IRequestFormDataProps } from "../options/IRequestFormDataProps";
-
-export namespace TypedFormDataBodyProgrammer {
-  export const generate = (props: {
-    context: INestiaTransformContext;
-    modulo: ts.LeftHandSideExpression;
-    type: ts.Type;
-  }): ts.ObjectLiteralExpression => {
-    // VALIDATE TYPE
-    const collection: MetadataCollection = new MetadataCollection();
-    const result = MetadataFactory.analyze({
-      checker: props.context.checker,
-      transformer: props.context.transformer,
-      options: {
-        escape: false,
-        constant: true,
-        absorb: true,
-        validate: HttpFormDataProgrammer.validate,
-      },
-      type: props.type,
-      collection,
-    });
-    if (result.success === false)
-      throw TransformerError.from({
-        code: "nestia.core.TypedFormData.Body",
-        errors: result.errors,
-      });
-
-    const files: IRequestFormDataProps.IFile[] =
-      result.data.objects[0].type.properties
-        .filter(
-          (p) =>
-            isFile(p.value) || p.value.arrays.some((a) => isFile(a.type.value)),
-        )
-        .map((p) => ({
-          name: p.key.constants[0].values[0].value as string,
-          limit: !!p.value.natives.length ? 1 : null,
-        }));
-
-    // GENERATE VALIDATION PLAN
-    const parameter =
-      (key: IRequestFormDataProps<any>["validator"]["type"]) =>
-      (
-        programmer: (next: {
-          context: ITypiaContext;
-          modulo: ts.LeftHandSideExpression;
-          type: ts.Type;
-          name: string | undefined;
-        }) => ts.Expression,
-      ) =>
-        ts.factory.createObjectLiteralExpression(
-          [
-            ts.factory.createPropertyAssignment(
-              ts.factory.createIdentifier("files"),
-              LiteralFactory.write(files),
-            ),
-            ts.factory.createPropertyAssignment(
-              ts.factory.createIdentifier("validator"),
-              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: {
-                          numeric: false,
-                          finite: false,
-                          functional: false,
-                        },
-                      },
-                      modulo: props.modulo,
-                      type: props.type,
-                      name: undefined,
-                    }),
-                  ),
-                ],
-                true,
-              ),
-            ),
-          ],
-          true,
-        );
-
-    // RETURNS
-    const category = props.context.options.validate;
-    if (category === "is" || category === "equals")
-      return parameter("is")(HttpIsFormDataProgrammer.write);
-    else if (
-      category === "validate" ||
-      category === "validateEquals" ||
-      category === "validateClone" ||
-      category === "validatePrune"
-    )
-      return parameter("validate")(HttpValidateFormDataProgrammer.write);
-    return parameter("assert")(HttpAssertFormDataProgrammer.write);
-  };
-}
-
-const isFile = (meta: Metadata) =>
-  meta.natives.some(({ name }) => name === "File" || name === "Blob");
+import ts from "typescript";
+import { LiteralFactory } from "typia/lib/factories/LiteralFactory";
+import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
+import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
+import { HttpAssertFormDataProgrammer } from "typia/lib/programmers/http/HttpAssertFormDataProgrammer";
+import { HttpFormDataProgrammer } from "typia/lib/programmers/http/HttpFormDataProgrammer";
+import { HttpIsFormDataProgrammer } from "typia/lib/programmers/http/HttpIsFormDataProgrammer";
+import { HttpValidateFormDataProgrammer } from "typia/lib/programmers/http/HttpValidateFormDataProgrammer";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
+import { TransformerError } from "typia/lib/transformers/TransformerError";
+
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
+import { IRequestFormDataProps } from "../options/IRequestFormDataProps";
+
+export namespace TypedFormDataBodyProgrammer {
+  export const generate = (props: {
+    context: INestiaTransformContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.ObjectLiteralExpression => {
+    // VALIDATE TYPE
+    const collection: MetadataCollection = new MetadataCollection();
+    const result = MetadataFactory.analyze({
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      options: {
+        escape: false,
+        constant: true,
+        absorb: true,
+        validate: HttpFormDataProgrammer.validate,
+      },
+      type: props.type,
+      collection,
+    });
+    if (result.success === false)
+      throw TransformerError.from({
+        code: "nestia.core.TypedFormData.Body",
+        errors: result.errors,
+      });
+
+    const files: IRequestFormDataProps.IFile[] =
+      result.data.objects[0].type.properties
+        .filter(
+          (p) =>
+            isFile(p.value) || p.value.arrays.some((a) => isFile(a.type.value)),
+        )
+        .map((p) => ({
+          name: p.key.constants[0].values[0].value as string,
+          limit: !!p.value.natives.length ? 1 : null,
+        }));
+
+    // GENERATE VALIDATION PLAN
+    const parameter =
+      (key: IRequestFormDataProps<any>["validator"]["type"]) =>
+      (
+        programmer: (next: {
+          context: ITypiaContext;
+          modulo: ts.LeftHandSideExpression;
+          type: ts.Type;
+          name: string | undefined;
+        }) => ts.Expression,
+      ) =>
+        ts.factory.createObjectLiteralExpression(
+          [
+            ts.factory.createPropertyAssignment(
+              ts.factory.createIdentifier("files"),
+              LiteralFactory.write(files),
+            ),
+            ts.factory.createPropertyAssignment(
+              ts.factory.createIdentifier("validator"),
+              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: {
+                          numeric: false,
+                          finite: false,
+                          functional: false,
+                        },
+                      },
+                      modulo: props.modulo,
+                      type: props.type,
+                      name: undefined,
+                    }),
+                  ),
+                ],
+                true,
+              ),
+            ),
+          ],
+          true,
+        );
+
+    // RETURNS
+    const category = props.context.options.validate;
+    if (category === "is" || category === "equals")
+      return parameter("is")(HttpIsFormDataProgrammer.write);
+    else if (
+      category === "validate" ||
+      category === "validateEquals" ||
+      category === "validateClone" ||
+      category === "validatePrune"
+    )
+      return parameter("validate")(HttpValidateFormDataProgrammer.write);
+    return parameter("assert")(HttpAssertFormDataProgrammer.write);
+  };
+}
+
+const isFile = (meta: Metadata) =>
+  meta.natives.some(({ name }) => name === "File" || name === "Blob");