@nestia/core 11.2.1 → 12.0.0-dev.20260521.1

package/src/programmers/PlainBodyProgrammer.ts

@@ -1,72 +0,0 @@
-import {
-  AssertProgrammer,
-  MetadataCollection,
-  MetadataFactory,
-  MetadataSchema,
-  TransformerError,
-} from "@typia/core";
-import ts from "typescript";
-
-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: ({ metadata }) => validate(metadata),
-      },
-      components: 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: MetadataSchema): 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,148 +0,0 @@
-import {
-  AssertProgrammer,
-  ITypiaContext,
-  IsProgrammer,
-  JsonMetadataFactory,
-  LlmSchemaProgrammer,
-  MiscAssertCloneProgrammer,
-  MiscAssertPruneProgrammer,
-  MiscValidateCloneProgrammer,
-  MiscValidatePruneProgrammer,
-  ValidateProgrammer,
-} from "@typia/core";
-import ts from "typescript";
-
-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
-        ? (next) =>
-            LlmSchemaProgrammer.validate({
-              config: {
-                strict:
-                  typeof props.context.options.llm === "boolean"
-                    ? false
-                    : (props.context.options.llm?.strict ?? false),
-              },
-              metadata: next.metadata,
-              explore: next.explore,
-            })
-        : 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 +0,0 @@
-import {
-  HttpAssertFormDataProgrammer,
-  HttpFormDataProgrammer,
-  HttpIsFormDataProgrammer,
-  HttpValidateFormDataProgrammer,
-  ITypiaContext,
-  LiteralFactory,
-  MetadataCollection,
-  MetadataFactory,
-  MetadataSchema,
-  TransformerError,
-} from "@typia/core";
-import ts from "typescript";
-
-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 storage: 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,
-      components: storage,
-    });
-    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: MetadataSchema) =>
-  meta.natives.some(({ name }) => name === "File" || name === "Blob");

package/src/programmers/TypedHeadersProgrammer.ts

@@ -1,65 +0,0 @@
-import {
-  HttpAssertHeadersProgrammer,
-  HttpIsHeadersProgrammer,
-  HttpValidateHeadersProgrammer,
-  ITypiaContext,
-} from "@typia/core";
-import ts from "typescript";
-
-import { INestiaTransformContext } from "../options/INestiaTransformProject";
-import { IRequestHeadersValidator } from "../options/IRequestHeadersValidator";
-
-export namespace TypedHeadersProgrammer {
-  export const generate = (props: {
-    context: INestiaTransformContext;
-    modulo: ts.LeftHandSideExpression;
-    type: ts.Type;
-  }): ts.Expression => {
-    // GENERATE VALIDATION PLAN
-    const parameter =
-      (key: IRequestHeadersValidator<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;
-    if (category === "is" || category === "equals")
-      return parameter("is")(HttpIsHeadersProgrammer.write);
-    else if (
-      category === "validate" ||
-      category === "validateEquals" ||
-      category === "validateClone" ||
-      category === "validatePrune"
-    )
-      return parameter("validate")(HttpValidateHeadersProgrammer.write);
-    return parameter("assert")(HttpAssertHeadersProgrammer.write);
-  };
-}

package/src/programmers/TypedParamProgrammer.ts

@@ -1,33 +0,0 @@
-import { HttpParameterProgrammer } from "@typia/core";
-import ts from "typescript";
-
-import { INestiaTransformContext } from "../options/INestiaTransformProject";
-
-export namespace TypedParamProgrammer {
-  export const generate = (props: {
-    context: INestiaTransformContext;
-    modulo: ts.LeftHandSideExpression;
-    arguments: readonly ts.Expression[];
-    type: ts.Type;
-  }): readonly ts.Expression[] => {
-    // ALREADY BEING TRANSFORMED
-    if (props.arguments.length !== 1) return props.arguments;
-    return [
-      props.arguments[0]!,
-      HttpParameterProgrammer.write({
-        context: {
-          ...props.context,
-          options: {
-            numeric: true,
-          },
-        },
-        modulo: props.modulo,
-        type: props.type,
-        name: undefined,
-      }),
-      ...(props.context.options?.validate?.startsWith("validate")
-        ? [ts.factory.createTrue()]
-        : []),
-    ];
-  };
-}

package/src/programmers/TypedQueryBodyProgrammer.ts

@@ -1,113 +0,0 @@
-import {
-  HttpAssertQueryProgrammer,
-  HttpIsQueryProgrammer,
-  HttpQueryProgrammer,
-  HttpValidateQueryProgrammer,
-  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 { IRequestQueryValidator } from "../options/IRequestQueryValidator";
-
-export namespace TypedQueryBodyProgrammer {
-  export const generate = (props: {
-    context: INestiaTransformContext;
-    modulo: ts.LeftHandSideExpression;
-    type: ts.Type;
-  }): ts.ObjectLiteralExpression => {
-    // VALIDATE TYPE
-    if (props.context.options.llm) {
-      const llm: INestiaTransformOptions.ILlm | true =
-        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: (next) => {
-              const errors: string[] = HttpQueryProgrammer.validate({
-                metadata: next.metadata,
-                explore: next.explore,
-                allowOptional: true,
-              });
-              errors.push(
-                ...LlmSchemaProgrammer.validate({
-                  config: {
-                    strict: llm === true ? false : (llm.strict ?? false),
-                  },
-                  metadata: next.metadata,
-                  explore: next.explore,
-                }),
-              );
-              return errors;
-            },
-          },
-          components: new MetadataCollection(),
-          type: props.type,
-        });
-      if (result.success === false)
-        throw TransformerError.from({
-          code: props.modulo.getText(),
-          errors: result.errors,
-        });
-    }
-
-    // GENERATE VALIDATION PLAN
-    const parameter =
-      (key: IRequestQueryValidator<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;
-    if (category === "is" || category === "equals")
-      return parameter("is")(HttpIsQueryProgrammer.write);
-    else if (
-      category === "validate" ||
-      category === "validateEquals" ||
-      category === "validateClone" ||
-      category === "validatePrune"
-    )
-      return parameter("validate")(HttpValidateQueryProgrammer.write);
-    return parameter("assert")(HttpAssertQueryProgrammer.write);
-  };
-}

package/src/programmers/TypedQueryProgrammer.ts

@@ -1,115 +0,0 @@
-import {
-  HttpAssertQueryProgrammer,
-  HttpIsQueryProgrammer,
-  HttpQueryProgrammer,
-  HttpValidateQueryProgrammer,
-  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 { IRequestQueryValidator } from "../options/IRequestQueryValidator";
-
-export namespace TypedQueryProgrammer {
-  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 | true =
-        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: (next) => {
-              const errors: string[] = HttpQueryProgrammer.validate({
-                metadata: next.metadata,
-                explore: next.explore,
-                allowOptional: true,
-              });
-              errors.push(
-                ...LlmSchemaProgrammer.validate({
-                  config: {
-                    strict: llm === true ? false : (llm.strict ?? false),
-                  },
-                  metadata: next.metadata,
-                  explore: next.explore,
-                }),
-              );
-              return errors;
-            },
-          },
-          components: new MetadataCollection(),
-          type: props.type,
-        });
-      if (result.success === false)
-        throw TransformerError.from({
-          code: "@nestia.core.TypedQuery",
-          errors: result.errors,
-        });
-    }
-
-    // GENERATE VALIDATION PLAN
-    const parameter =
-      (key: IRequestQueryValidator<any>["type"]) =>
-      (
-        programmer: (next: {
-          context: ITypiaContext;
-          modulo: ts.LeftHandSideExpression;
-          type: ts.Type;
-          name: string | undefined;
-          allowOptional: boolean;
-        }) => 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,
-              allowOptional: true,
-            }),
-          ),
-        ]);
-
-    // RETURNS
-    const category = props.context.options.validate;
-    if (category === "is" || category === "equals")
-      return parameter("is")(HttpIsQueryProgrammer.write);
-    else if (
-      category === "validate" ||
-      category === "validateEquals" ||
-      category === "validateClone" ||
-      category === "validatePrune"
-    )
-      return parameter("validate")(HttpValidateQueryProgrammer.write);
-    return parameter("assert")(HttpAssertQueryProgrammer.write);
-  };
-}