@nestia/core 10.0.2 → 11.0.0-dev.20260305

package/src/options/INestiaTransformOptions.ts

@@ -1,34 +1,34 @@
-export interface INestiaTransformOptions {
-  validate?: INestiaTransformOptions.Validate;
-  stringify?: INestiaTransformOptions.Stringify | null;
-  llm?: INestiaTransformOptions.ILlm;
-  throws?: boolean;
-}
-export namespace INestiaTransformOptions {
-  export type Validate =
-    // NORMAL
-    | "assert"
-    | "is"
-    | "validate"
-    // STRICT
-    | "assertEquals"
-    | "equals"
-    | "validateEquals"
-    // CLONE
-    | "assertClone"
-    | "validateClone"
-    // PRUNE
-    | "assertPrune"
-    | "validatePrune";
-
-  export type Stringify =
-    | "stringify"
-    | "assert"
-    | "is"
-    | "validate"
-    | "validate.log";
-
-  export interface ILlm {
-    strict?: boolean;
-  }
-}
+export interface INestiaTransformOptions {
+  validate?: INestiaTransformOptions.Validate;
+  stringify?: INestiaTransformOptions.Stringify | null;
+  llm?: INestiaTransformOptions.ILlm;
+  throws?: boolean;
+}
+export namespace INestiaTransformOptions {
+  export type Validate =
+    // NORMAL
+    | "assert"
+    | "is"
+    | "validate"
+    // STRICT
+    | "assertEquals"
+    | "equals"
+    | "validateEquals"
+    // CLONE
+    | "assertClone"
+    | "validateClone"
+    // PRUNE
+    | "assertPrune"
+    | "validatePrune";
+
+  export type Stringify =
+    | "stringify"
+    | "assert"
+    | "is"
+    | "validate"
+    | "validate.log";
+
+  export interface ILlm {
+    strict?: boolean;
+  }
+}

package/src/options/INestiaTransformProject.ts

@@ -1,8 +1,10 @@
-import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
-
-import { INestiaTransformOptions } from "./INestiaTransformOptions";
-
-export interface INestiaTransformContext
-  extends Omit<ITypiaContext, "options"> {
-  options: INestiaTransformOptions;
-}
+import { ITypiaContext } from "@typia/core";
+
+import { INestiaTransformOptions } from "./INestiaTransformOptions";
+
+export interface INestiaTransformContext extends Omit<
+  ITypiaContext,
+  "options"
+> {
+  options: INestiaTransformOptions;
+}

package/src/options/IRequestBodyValidator.ts

@@ -1,20 +1,20 @@
-import { IValidation } from "typia";
-
-export type IRequestBodyValidator<T> =
-  | IRequestBodyValidator.IAssert<T>
-  | IRequestBodyValidator.IIs<T>
-  | IRequestBodyValidator.IValidate<T>;
-export namespace IRequestBodyValidator {
-  export interface IAssert<T> {
-    type: "assert";
-    assert: (input: T) => T;
-  }
-  export interface IIs<T> {
-    type: "is";
-    is: (input: T) => boolean;
-  }
-  export interface IValidate<T> {
-    type: "validate";
-    validate: (input: T) => IValidation<T>;
-  }
-}
+import { IValidation } from "typia";
+
+export type IRequestBodyValidator<T> =
+  | IRequestBodyValidator.IAssert<T>
+  | IRequestBodyValidator.IIs<T>
+  | IRequestBodyValidator.IValidate<T>;
+export namespace IRequestBodyValidator {
+  export interface IAssert<T> {
+    type: "assert";
+    assert: (input: T) => T;
+  }
+  export interface IIs<T> {
+    type: "is";
+    is: (input: T) => boolean;
+  }
+  export interface IValidate<T> {
+    type: "validate";
+    validate: (input: T) => IValidation<T>;
+  }
+}

package/src/options/IRequestFormDataProps.ts

@@ -1,27 +1,27 @@
-import { IValidation } from "typia";
-
-export interface IRequestFormDataProps<T> {
-  files: Array<IRequestFormDataProps.IFile>;
-  validator:
-    | IRequestFormDataProps.IAssert<T>
-    | IRequestFormDataProps.IIs<T>
-    | IRequestFormDataProps.IValidate<T>;
-}
-export namespace IRequestFormDataProps {
-  export interface IAssert<T> {
-    type: "assert";
-    assert: (input: FormData) => T;
-  }
-  export interface IIs<T> {
-    type: "is";
-    is: (input: FormData) => T | null;
-  }
-  export interface IValidate<T> {
-    type: "validate";
-    validate: (input: FormData) => IValidation<T>;
-  }
-  export interface IFile {
-    name: string;
-    limit: number | null;
-  }
-}
+import { IValidation } from "typia";
+
+export interface IRequestFormDataProps<T> {
+  files: Array<IRequestFormDataProps.IFile>;
+  validator:
+    | IRequestFormDataProps.IAssert<T>
+    | IRequestFormDataProps.IIs<T>
+    | IRequestFormDataProps.IValidate<T>;
+}
+export namespace IRequestFormDataProps {
+  export interface IAssert<T> {
+    type: "assert";
+    assert: (input: FormData) => T;
+  }
+  export interface IIs<T> {
+    type: "is";
+    is: (input: FormData) => T | null;
+  }
+  export interface IValidate<T> {
+    type: "validate";
+    validate: (input: FormData) => IValidation<T>;
+  }
+  export interface IFile {
+    name: string;
+    limit: number | null;
+  }
+}

package/src/options/IRequestHeadersValidator.ts

@@ -1,22 +1,22 @@
-import { IValidation } from "typia";
-
-export type IRequestHeadersValidator<T> =
-  | IRequestHeadersValidator.IAssert<T>
-  | IRequestHeadersValidator.IIs<T>
-  | IRequestHeadersValidator.IValidate<T>;
-export namespace IRequestHeadersValidator {
-  export interface IAssert<T> {
-    type: "assert";
-    assert: (input: Record<string, string | string[] | undefined>) => T;
-  }
-  export interface IIs<T> {
-    type: "is";
-    is: (input: Record<string, string | string[] | undefined>) => T | null;
-  }
-  export interface IValidate<T> {
-    type: "validate";
-    validate: (
-      input: Record<string, string | string[] | undefined>,
-    ) => IValidation<T>;
-  }
-}
+import { IValidation } from "typia";
+
+export type IRequestHeadersValidator<T> =
+  | IRequestHeadersValidator.IAssert<T>
+  | IRequestHeadersValidator.IIs<T>
+  | IRequestHeadersValidator.IValidate<T>;
+export namespace IRequestHeadersValidator {
+  export interface IAssert<T> {
+    type: "assert";
+    assert: (input: Record<string, string | string[] | undefined>) => T;
+  }
+  export interface IIs<T> {
+    type: "is";
+    is: (input: Record<string, string | string[] | undefined>) => T | null;
+  }
+  export interface IValidate<T> {
+    type: "validate";
+    validate: (
+      input: Record<string, string | string[] | undefined>,
+    ) => IValidation<T>;
+  }
+}

package/src/options/IRequestQueryValidator.ts

@@ -1,20 +1,20 @@
-import { IValidation } from "typia";
-
-export type IRequestQueryValidator<T> =
-  | IRequestQueryValidator.IAssert<T>
-  | IRequestQueryValidator.IIs<T>
-  | IRequestQueryValidator.IValidate<T>;
-export namespace IRequestQueryValidator {
-  export interface IAssert<T> {
-    type: "assert";
-    assert: (input: URLSearchParams) => T;
-  }
-  export interface IIs<T> {
-    type: "is";
-    is: (input: URLSearchParams) => T | null;
-  }
-  export interface IValidate<T> {
-    type: "validate";
-    validate: (input: URLSearchParams) => IValidation<T>;
-  }
-}
+import { IValidation } from "typia";
+
+export type IRequestQueryValidator<T> =
+  | IRequestQueryValidator.IAssert<T>
+  | IRequestQueryValidator.IIs<T>
+  | IRequestQueryValidator.IValidate<T>;
+export namespace IRequestQueryValidator {
+  export interface IAssert<T> {
+    type: "assert";
+    assert: (input: URLSearchParams) => T;
+  }
+  export interface IIs<T> {
+    type: "is";
+    is: (input: URLSearchParams) => T | null;
+  }
+  export interface IValidate<T> {
+    type: "validate";
+    validate: (input: URLSearchParams) => IValidation<T>;
+  }
+}

package/src/options/IResponseBodyQuerifier.ts

@@ -1,25 +1,25 @@
-import { IValidation } from "typia";
-
-export type IResponseBodyQuerifier<T> =
-  | IResponseBodyquerifier.IStringify<T>
-  | IResponseBodyquerifier.IIs<T>
-  | IResponseBodyquerifier.IAssert<T>
-  | IResponseBodyquerifier.IValidate<T>;
-export namespace IResponseBodyquerifier {
-  export interface IStringify<T> {
-    type: "stringify";
-    stringify: (input: T) => URLSearchParams;
-  }
-  export interface IIs<T> {
-    type: "is";
-    is: (input: T) => URLSearchParams | null;
-  }
-  export interface IAssert<T> {
-    type: "assert";
-    assert: (input: T) => URLSearchParams;
-  }
-  export interface IValidate<T> {
-    type: "validate";
-    validate: (input: T) => IValidation<URLSearchParams>;
-  }
-}
+import { IValidation } from "typia";
+
+export type IResponseBodyQuerifier<T> =
+  | IResponseBodyquerifier.IStringify<T>
+  | IResponseBodyquerifier.IIs<T>
+  | IResponseBodyquerifier.IAssert<T>
+  | IResponseBodyquerifier.IValidate<T>;
+export namespace IResponseBodyquerifier {
+  export interface IStringify<T> {
+    type: "stringify";
+    stringify: (input: T) => URLSearchParams;
+  }
+  export interface IIs<T> {
+    type: "is";
+    is: (input: T) => URLSearchParams | null;
+  }
+  export interface IAssert<T> {
+    type: "assert";
+    assert: (input: T) => URLSearchParams;
+  }
+  export interface IValidate<T> {
+    type: "validate";
+    validate: (input: T) => IValidation<URLSearchParams>;
+  }
+}

package/src/options/IResponseBodyStringifier.ts

@@ -1,30 +1,30 @@
-import { IValidation } from "typia";
-
-export type IResponseBodyStringifier<T> =
-  | IResponseBodyStringifier.IStringify<T>
-  | IResponseBodyStringifier.IIs<T>
-  | IResponseBodyStringifier.IAssert<T>
-  | IResponseBodyStringifier.IValidate<T>
-  | IResponseBodyStringifier.IValidateLog<T>;
-export namespace IResponseBodyStringifier {
-  export interface IStringify<T> {
-    type: "stringify";
-    stringify: (input: T) => string;
-  }
-  export interface IIs<T> {
-    type: "is";
-    is: (input: T) => string | null;
-  }
-  export interface IAssert<T> {
-    type: "assert";
-    assert: (input: T) => string;
-  }
-  export interface IValidate<T> {
-    type: "validate";
-    validate: (input: T) => IValidation<string>;
-  }
-  export interface IValidateLog<T> {
-    type: "validate.log";
-    validate: (input: T) => IValidation<string>;
-  }
-}
+import { IValidation } from "typia";
+
+export type IResponseBodyStringifier<T> =
+  | IResponseBodyStringifier.IStringify<T>
+  | IResponseBodyStringifier.IIs<T>
+  | IResponseBodyStringifier.IAssert<T>
+  | IResponseBodyStringifier.IValidate<T>
+  | IResponseBodyStringifier.IValidateLog<T>;
+export namespace IResponseBodyStringifier {
+  export interface IStringify<T> {
+    type: "stringify";
+    stringify: (input: T) => string;
+  }
+  export interface IIs<T> {
+    type: "is";
+    is: (input: T) => string | null;
+  }
+  export interface IAssert<T> {
+    type: "assert";
+    assert: (input: T) => string;
+  }
+  export interface IValidate<T> {
+    type: "validate";
+    validate: (input: T) => IValidation<string>;
+  }
+  export interface IValidateLog<T> {
+    type: "validate.log";
+    validate: (input: T) => IValidation<string>;
+  }
+}

package/src/programmers/PlainBodyProgrammer.ts

@@ -1,70 +1,72 @@
-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 {
+  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,
+      },
+      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;
+};