typia 3.5.0-dev.20230126 → 3.5.0-dev.20230212

package/src/programmers/helpers/StringifyJoinder.ts

@@ -11,12 +11,15 @@ import { IExpressionEntry } from "./IExpressionEntry";
 export namespace StringifyJoiner {
     export const object =
         (importer: FunctionImporter) =>
-        (entries: IExpressionEntry[]): ts.Expression => {
+        (
+            _input: ts.Expression,
+            entries: IExpressionEntry<ts.Expression>[],
+        ): ts.Expression => {
             // CHECK AND SORT ENTRIES
-            const regular: IExpressionEntry[] = entries.filter((entry) =>
-                entry.key.isSoleLiteral(),
+            const regular: IExpressionEntry<ts.Expression>[] = entries.filter(
+                (entry) => entry.key.isSoleLiteral(),
             );
-            const dynamic: IExpressionEntry[] = entries.filter(
+            const dynamic: IExpressionEntry<ts.Expression>[] = entries.filter(
                 (entry) => !entry.key.isSoleLiteral(),
             );
             if (regular.length === 0 && dynamic.length === 0)

package/src/programmers/internal/application_object.ts

@@ -18,10 +18,10 @@ import { metadata_to_pattern } from "./metadata_to_pattern";
 export const application_object =
     (options: ApplicationProgrammer.IOptions) =>
     (components: IJsonComponents) =>
-    (id: string, obj: MetadataObject, nullable: boolean): void => {
+    (key: string, obj: MetadataObject, nullable: boolean): void => {
         // TEMPORARY ASSIGNMENT
-        if (components.schemas[id] !== undefined) return;
-        components.schemas[id] = {} as any;
+        if (components.schemas[key] !== undefined) return;
+        components.schemas[key] = {} as any;
 
         // ITERATE PROPERTIES
         const properties: Record<string, any> = {};
@@ -97,7 +97,7 @@ export const application_object =
         const schema: IJsonComponents.IObject = {
             $id:
                 options.purpose === "ajv"
-                    ? options.prefix + "/" + id
+                    ? options.prefix + "/" + key
                     : undefined,
             $recursiveAnchor:
                 (options.purpose === "ajv" && obj.recursive) || undefined,
@@ -118,7 +118,7 @@ export const application_object =
                           join(options)(components)(extraMeta),
                   }),
         };
-        components.schemas[id] = schema;
+        components.schemas[key] = schema;
     };
 
 const join =

package/src/programmers/internal/application_schema.ts

@@ -2,8 +2,6 @@ import { Metadata } from "../../metadata/Metadata";
 import { IJsonComponents } from "../../schemas/IJsonComponents";
 import { IJsonSchema } from "../../schemas/IJsonSchema";
 
-import { NameEncoder } from "../../utils/NameEncoder";
-
 import { ApplicationProgrammer } from "../ApplicationProgrammer";
 import { AtomicPredicator } from "../helpers/AtomicPredicator";
 import { application_array } from "./application_array";
@@ -48,27 +46,28 @@ export const application_schema =
         // ATOMIC TYPES
         if (meta.templates.length && AtomicPredicator.template(meta))
             union.push(application_templates(meta, attribute));
-        for (const constant of meta.constants) {
+        for (const constant of meta.constants)
             if (constant.type === "bigint") throw new Error(NO_BIGINT);
             else if (
                 (constant.type === "string" && meta.templates.length) ||
                 AtomicPredicator.constant(meta)(constant.type) === false
             )
                 continue;
-            union.push(
-                application_constant(constant, meta.nullable, attribute),
-            );
-        }
-        for (const type of meta.atomics) {
+            else
+                union.push(
+                    application_constant(constant, meta.nullable, attribute),
+                );
+        for (const type of meta.atomics)
             if (type === "bigint") throw new Error(NO_BIGINT);
-            union.push(
-                type === "string"
-                    ? application_string(meta, attribute)
-                    : type === "boolean"
-                    ? application_boolean(meta.nullable, attribute)
-                    : application_number(meta.nullable, attribute),
-            );
-        }
+            else if (AtomicPredicator.atomic(meta)(type) === false) continue;
+            else
+                union.push(
+                    type === "string"
+                        ? application_string(meta, attribute)
+                        : type === "boolean"
+                        ? application_boolean(meta.nullable, attribute)
+                        : application_number(meta.nullable, attribute),
+                );
 
         // ARRAY
         for (const schema of meta.arrays.values())
@@ -111,12 +110,21 @@ export const application_schema =
 
         // NATIVES
         for (const native of meta.natives)
-            union.push(
-                application_native(options)(components)(native)(
-                    meta.nullable,
-                    attribute,
-                ),
-            );
+            if (AtomicPredicator.native(native))
+                union.push(
+                    native === "String"
+                        ? application_string(meta, attribute)
+                        : native === "Boolean"
+                        ? application_boolean(meta.nullable, attribute)
+                        : application_number(meta.nullable, attribute),
+                );
+            else
+                union.push(
+                    application_native(options)(components)(native)(
+                        meta.nullable,
+                        attribute,
+                    ),
+                );
         if (meta.sets.length)
             union.push(
                 application_native(options)(components)(`Set`)(
@@ -134,14 +142,12 @@ export const application_schema =
 
         // OBJECT
         for (const obj of meta.objects) {
-            const id: string =
-                NameEncoder.encode(obj.name) +
-                (meta.nullable ? ".Nullable" : "");
-            application_object(options)(components)(id, obj, meta.nullable);
+            const key: string = obj.name + (meta.nullable ? ".Nullable" : "");
+            application_object(options)(components)(key, obj, meta.nullable);
             union.push(
                 (options.purpose === "ajv" && obj.recursive
                     ? recursive
-                    : reference)(`${options.prefix}/${id}`, attribute),
+                    : reference)(`${options.prefix}/${key}`, attribute),
             );
         }
 

package/src/programmers/internal/check_dynamic_properties.ts

@@ -3,6 +3,7 @@ import ts from "typescript";
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 
+import { FunctionImporter } from "../helpers/FunctionImporeter";
 import { IExpressionEntry } from "../helpers/IExpressionEntry";
 import { check_everything } from "./check_everything";
 import { check_object } from "./check_object";
@@ -13,39 +14,87 @@ import { metadata_to_pattern } from "./metadata_to_pattern";
  */
 export const check_dynamic_properties =
     (props: check_object.IProps) =>
+    (importer: FunctionImporter) =>
     (
-        regular: IExpressionEntry[],
-        dynamic: IExpressionEntry[],
+        input: ts.Expression,
+        regular: IExpressionEntry<ts.Expression>[],
+        dynamic: IExpressionEntry<ts.Expression>[],
     ): ts.Expression => {
+        const length = IdentifierFactory.join(
+            ts.factory.createCallExpression(
+                ts.factory.createIdentifier("Object.keys"),
+                undefined,
+                [input],
+            ),
+            "length",
+        );
+        const left: ts.Expression | null =
+            props.equals === true && dynamic.length === 0
+                ? props.undefined === true ||
+                  regular.every((r) => r.meta.required)
+                    ? ts.factory.createStrictEquality(
+                          ts.factory.createNumericLiteral(
+                              regular.filter((r) => r.meta.required).length,
+                          ),
+                          length,
+                      )
+                    : ts.factory.createCallExpression(
+                          importer.use("is_between"),
+                          [],
+                          [
+                              length,
+                              ts.factory.createNumericLiteral(
+                                  regular.filter((r) => r.meta.required).length,
+                              ),
+                              ts.factory.createNumericLiteral(regular.length),
+                          ],
+                      )
+                : null;
+        if (
+            props.undefined === false &&
+            left !== null &&
+            regular.every((r) => r.meta.required)
+        )
+            return left;
+
         const criteria = props.entries
             ? ts.factory.createCallExpression(props.entries, undefined, [
                   ts.factory.createCallExpression(
                       ts.factory.createIdentifier("Object.keys"),
                       undefined,
-                      [ts.factory.createIdentifier("input")],
+                      [input],
                   ),
-                  check_dynamic_property(props)(regular, dynamic),
+                  check_dynamic_property(props)(input, regular, dynamic),
               ])
             : ts.factory.createCallExpression(
                   IdentifierFactory.join(
                       ts.factory.createCallExpression(
                           ts.factory.createIdentifier("Object.keys"),
                           undefined,
-                          [ts.factory.createIdentifier("input")],
+                          [input],
                       ),
                       props.assert ? "every" : "map",
                   ),
                   undefined,
-                  [check_dynamic_property(props)(regular, dynamic)],
+                  [check_dynamic_property(props)(input, regular, dynamic)],
               );
-        return (props.halt || ((elem) => elem))(
+        const right: ts.Expression = (props.halt || ((elem) => elem))(
             props.assert ? criteria : check_everything(criteria),
         );
+        return left
+            ? (props.undefined
+                  ? ts.factory.createLogicalOr
+                  : ts.factory.createLogicalAnd)(left, right)
+            : right;
     };
 
 const check_dynamic_property =
     (props: check_object.IProps) =>
-    (regular: IExpressionEntry[], dynamic: IExpressionEntry[]) => {
+    (
+        input: ts.Expression,
+        regular: IExpressionEntry<ts.Expression>[],
+        dynamic: IExpressionEntry<ts.Expression>[],
+    ) => {
         //----
         // IF CONDITIONS
         //----
@@ -68,16 +117,18 @@ const check_dynamic_property =
         statements.push(
             StatementFactory.constant(
                 "value",
-                ts.factory.createIdentifier("input[key]"),
-            ),
-        );
-        add(
-            ts.factory.createStrictEquality(
-                ts.factory.createIdentifier("undefined"),
-                value,
+                ts.factory.createElementAccessExpression(input, key),
             ),
-            props.positive,
         );
+        if (props.undefined === true)
+            add(
+                ts.factory.createStrictEquality(
+                    ts.factory.createIdentifier("undefined"),
+                    value,
+                ),
+                props.positive,
+            );
+
         for (const entry of dynamic)
             add(
                 ts.factory.createCallExpression(

package/src/programmers/internal/check_native.ts

@@ -5,5 +5,17 @@ import { ExpressionFactory } from "../../factories/ExpressionFactory";
 /**
  * @internal
  */
-export const check_native = (type: string) => (input: ts.Expression) =>
-    ExpressionFactory.isInstanceOf(input, type);
+export const check_native = (type: string) => (input: ts.Expression) => {
+    const instanceOf = ExpressionFactory.isInstanceOf(input, type);
+    return ATOMIC_LIKE.has(type)
+        ? ts.factory.createLogicalOr(
+              ts.factory.createStrictEquality(
+                  ts.factory.createStringLiteral(type.toLowerCase()),
+                  ts.factory.createTypeOfExpression(input),
+              ),
+              instanceOf,
+          )
+        : instanceOf;
+};
+
+const ATOMIC_LIKE = new Set(["Boolean", "Number", "String"]);

package/src/programmers/internal/check_object.ts

@@ -1,5 +1,6 @@
 import ts from "typescript";
 
+import { FunctionImporter } from "../helpers/FunctionImporeter";
 import { IExpressionEntry } from "../helpers/IExpressionEntry";
 import { check_dynamic_properties } from "./check_dynamic_properties";
 import { check_everything } from "./check_everything";
@@ -8,7 +9,9 @@ import { check_everything } from "./check_everything";
  * @internal
  */
 export const check_object =
-    (props: check_object.IProps) => (entries: IExpressionEntry[]) => {
+    (props: check_object.IProps) =>
+    (importer: FunctionImporter) =>
+    (input: ts.Expression, entries: IExpressionEntry<ts.Expression>[]) => {
         // PREPARE ASSETS
         const regular = entries.filter((entry) => entry.key.isSoleLiteral());
         const dynamic = entries.filter((entry) => !entry.key.isSoleLiteral());
@@ -19,13 +22,16 @@ export const check_object =
             return regular.length === 0 ? props.positive : reduce(props)(flags);
 
         // CHECK DYNAMIC PROPERTIES
-        flags.push(check_dynamic_properties(props)(regular, dynamic));
+        flags.push(
+            check_dynamic_properties(props)(importer)(input, regular, dynamic),
+        );
         return reduce(props)(flags);
     };
 export namespace check_object {
     export interface IProps {
         equals: boolean;
         assert: boolean;
+        undefined: boolean;
         halt?: (exp: ts.Expression) => ts.Expression;
         reduce: (a: ts.Expression, b: ts.Expression) => ts.Expression;
         positive: ts.Expression;

package/src/programmers/internal/check_union_array_like.ts

@@ -180,7 +180,9 @@ export const check_union_array_like =
                               ts.factory.createNumericLiteral(0),
                               accessor.size(input),
                           ),
-                          ts.factory.createReturnStatement(props.empty),
+                          ts.isReturnStatement(props.empty)
+                              ? props.empty
+                              : ts.factory.createReturnStatement(props.empty),
                       ),
                   ]
                 : []),
@@ -224,7 +226,7 @@ export namespace check_union_array_like {
             array: ts.Expression,
         ): ts.Expression;
         decoder: UnionExplorer.Decoder<T>;
-        empty: ts.Expression;
+        empty: ts.ReturnStatement | ts.Expression;
         success: ts.Expression;
         failure(
             input: ts.Expression,

package/src/programmers/internal/feature_object_entries.ts

@@ -9,7 +9,12 @@ import { Escaper } from "../../utils/Escaper";
 import { FeatureProgrammer } from "../FeatureProgrammer";
 
 export const feature_object_entries =
-    (config: Pick<FeatureProgrammer.IConfig, "decoder" | "path" | "trace">) =>
+    <Output extends ts.ConciseBody>(
+        config: Pick<
+            FeatureProgrammer.IConfig<Output>,
+            "decoder" | "path" | "trace"
+        >,
+    ) =>
     (obj: MetadataObject) =>
     (input: ts.Expression) =>
         obj.properties.map((prop) => {

package/src/programmers/internal/prune_object_properties.ts

@@ -0,0 +1,60 @@
+import ts from "typescript";
+
+import { StatementFactory } from "../../factories/StatementFactory";
+
+import { MetadataObject } from "../../metadata/MetadataObject";
+
+import { metadata_to_pattern } from "./metadata_to_pattern";
+
+/**
+ * @internal
+ */
+export const prune_object_properties = (obj: MetadataObject) => {
+    const input: ts.Expression = ts.factory.createIdentifier("input");
+    const key: ts.Expression = ts.factory.createIdentifier("key");
+
+    const condition: ts.Expression[] = obj.properties.map((prop) => {
+        const name: string | null = prop.key.getSoleLiteral();
+        if (name !== null)
+            return ts.factory.createStrictEquality(
+                ts.factory.createStringLiteral(name),
+                ts.factory.createIdentifier("key"),
+            );
+        return ts.factory.createCallExpression(
+            ts.factory.createIdentifier(
+                `RegExp(/${metadata_to_pattern(true)(prop.key)}/).test`,
+            ),
+            undefined,
+            [key],
+        );
+    });
+
+    const statements: ts.Statement[] = [];
+    if (condition.length)
+        statements.push(
+            ts.factory.createIfStatement(
+                condition.reduce((a, b) => ts.factory.createLogicalOr(a, b)),
+                ts.factory.createContinueStatement(),
+            ),
+        );
+    statements.push(
+        ts.factory.createExpressionStatement(
+            ts.factory.createDeleteExpression(
+                ts.factory.createElementAccessExpression(input, key),
+            ),
+        ),
+    );
+
+    return ts.factory.createForOfStatement(
+        undefined,
+        StatementFactory.constant("key").declarationList,
+        ts.factory.createCallExpression(
+            ts.factory.createIdentifier("Object.keys"),
+            undefined,
+            [input],
+        ),
+        statements.length === 1
+            ? statements[0]!
+            : ts.factory.createBlock(statements, true),
+    );
+};

package/src/programmers/internal/stringify_dynamic_properties.ts

@@ -10,7 +10,7 @@ import { metadata_to_pattern } from "./metadata_to_pattern";
  * @internal
  */
 export function stringify_dynamic_properties(
-    dynamic: IExpressionEntry[],
+    dynamic: IExpressionEntry<ts.Expression>[],
     regular: string[],
 ): ts.Expression {
     // BASIC STATMEMENT, CHECK UNDEFINED
@@ -149,7 +149,7 @@ export function stringify_dynamic_properties(
     return output();
 }
 
-function stringify(entry: IExpressionEntry): ts.ReturnStatement {
+function stringify(entry: IExpressionEntry<ts.Expression>): ts.ReturnStatement {
     return ts.factory.createReturnStatement(
         TemplateFactory.generate([
             ts.factory.createCallExpression(

package/src/programmers/internal/stringify_regular_properties.ts

@@ -11,8 +11,8 @@ import { IExpressionEntry } from "../helpers/IExpressionEntry";
  * @internal
  */
 export function stringify_regular_properties(
-    regular: IExpressionEntry[],
-    dynamic: IExpressionEntry[],
+    regular: IExpressionEntry<ts.Expression>[],
+    dynamic: IExpressionEntry<ts.Expression>[],
 ): ts.Expression[] {
     const output: ts.Expression[] = [];
 

package/src/transformers/CallExpressionTransformer.ts

@@ -3,14 +3,21 @@ import ts from "typescript";
 
 import { IProject } from "./IProject";
 import { ApplicationTransformer } from "./features/miscellaneous/ApplicationTransformer";
+import { AssertPruneTransformer } from "./features/miscellaneous/AssertPruneTransformer";
+import { CreateAssertPruneTransformer } from "./features/miscellaneous/CreateAssertPruneTransformer";
+import { CreateIsPruneTransformer } from "./features/miscellaneous/CreateIsPruneTransformer";
+import { CreatePruneTransformer } from "./features/miscellaneous/CreatePruneTransformer";
+import { CreateValidatePruneTransformer } from "./features/miscellaneous/CreateValidatePruneTransformer";
+import { IsPruneTransformer } from "./features/miscellaneous/IsPruneTransformer";
 import { MetadataTransformer } from "./features/miscellaneous/MetadataTransformer";
+import { PruneTransformer } from "./features/miscellaneous/PruneTransformer";
+import { ValidatePruneTransformer } from "./features/miscellaneous/ValidatePruneTransformer";
 import { AssertParseTransformer } from "./features/parsers/AssertParseTransformer";
 import { CreateAssertParseTransformer } from "./features/parsers/CreateAssertParseTransformer";
 import { CreateIsParseTransformer } from "./features/parsers/CreateIsParseTransformer";
 import { CreateValidateParseTransformer } from "./features/parsers/CreateValidateParseTransformer";
 import { IsParseTransformer } from "./features/parsers/IsParseTransformer";
 import { ValidateParseTransformer } from "./features/parsers/ValidateParseTransformer";
-import { MessageTransformer } from "./features/protocols/MessageTransformer";
 import { AssertStringifyTransformer } from "./features/stringifiers/AssertStringifyTransformer";
 import { CreateAssertStringifyTransformer } from "./features/stringifiers/CreateAssertStringifyTransformer";
 import { CreateIsStringifyTransformer } from "./features/stringifiers/CreateIsStringifyTransformer";
@@ -70,7 +77,7 @@ const SRC_PATH = path.resolve(path.join(__dirname, "..", "module.ts"));
 
 const FUNCTORS: Record<string, () => Task> = {
     //----
-    // VALIDATORS
+    // SINGLE FUNCTIONS
     //----
     // BASIC VALIDATORS
     assert: () => AssertTransformer.transform(false),
@@ -83,18 +90,7 @@ const FUNCTORS: Record<string, () => Task> = {
     equals: () => IsTransformer.transform(true),
     validateEquals: () => ValidateTransformer.transform(true),
 
-    //----
-    // PROTOCOL BUFFER
-    //----
-    message: () => MessageTransformer.transform,
-
-    //----
-    // JSON FUNCTIONS
-    //----
-    // SCHEMA DEFINITION
-    application: () => ApplicationTransformer.transform,
-
-    // PARSER FUNCTIONS
+    // PARSE FUNCTIONS
     isParse: () => IsParseTransformer.transform,
     assertParse: () => AssertParseTransformer.transform,
     validateParse: () => ValidateParseTransformer.transform,
@@ -106,26 +102,41 @@ const FUNCTORS: Record<string, () => Task> = {
     validateStringify: () => ValidateStringifyTransformer.transform,
 
     // MISC
+    application: () => ApplicationTransformer.transform,
     metadata: () => MetadataTransformer.transform,
+    prune: () => PruneTransformer.transform,
+    assertPrune: () => AssertPruneTransformer.transform,
+    isPrune: () => IsPruneTransformer.transform,
+    validatePrune: () => ValidatePruneTransformer.transform,
 
     //----
     // FACTORY FUNCTIONS
     //----
-    // VALIDATORS
+    // BASIC VALIDATORS
     createAssert: () => CreateAssertTransformer.transform(false),
     createAssertType: () => CreateAssertTransformer.transform(false),
     createIs: () => CreateIsTransformer.transform(false),
     createValidate: () => CreateValidateTransformer.transform(false),
+
+    // STRICT VALIDATORS
     createAssertEquals: () => CreateAssertTransformer.transform(true),
     createEquals: () => CreateIsTransformer.transform(true),
     createValidateEquals: () => CreateValidateTransformer.transform(true),
 
-    // JSON FUNCTIONS
+    // PARSE FUNCTIONS
     createIsParse: () => CreateIsParseTransformer.transform,
     createAssertParse: () => CreateAssertParseTransformer.transform,
     createValidateParse: () => CreateValidateParseTransformer.transform,
+
+    // STRINGIFY FUNCTIONS
     createStringify: () => CreateStringifyTransformer.transform,
     createAssertStringify: () => CreateAssertStringifyTransformer.transform,
     createIsStringify: () => CreateIsStringifyTransformer.transform,
     createValidateStringify: () => CreateValidateStringifyTransformer.transform,
+
+    // MISC
+    createPrune: () => CreatePruneTransformer.transform,
+    createAssertPrune: () => CreateAssertPruneTransformer.transform,
+    createIsPrune: () => CreateIsPruneTransformer.transform,
+    createValidatePrune: () => CreateValidatePruneTransformer.transform,
 };

package/src/transformers/ITransformOptions.ts

@@ -44,4 +44,19 @@ export interface ITransformOptions {
      * @default false
      */
     functional?: boolean;
+
+    /**
+     * Whether to check undefined value or not.
+     *
+     * JavaScript can assign `undefined` value to a specific property and it is an
+     * issue when validating without allowing superfluous properties. Should undefined
+     * value assigned superfluous property be allowed or not?
+     *
+     * Note that, this option only works on {@link equals} function. Other function
+     * like {@link assertEquals} or {@link validateEquals} would ignore this option
+     * value and always allow the `undefined` value.
+     *
+     * @default true
+     */
+    undefined?: boolean;
 }

package/src/transformers/features/miscellaneous/ApplicationTransformer.ts

@@ -59,7 +59,9 @@ export namespace ApplicationTransformer {
         // GENERATORS
         //----
         // METADATA
-        const collection: MetadataCollection = new MetadataCollection();
+        const collection: MetadataCollection = new MetadataCollection({
+            replace: MetadataCollection.replace,
+        });
         const metadatas: Array<Metadata> = types.map((type) =>
             MetadataFactory.generate(checker, collection, type, {
                 resolve: true,

package/src/transformers/features/miscellaneous/AssertPruneTransformer.ts

@@ -0,0 +1,38 @@
+import ts from "typescript";
+
+import { AssertPruneProgrammer } from "../../../programmers/AssertPruneProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace AssertPruneTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        if (expression.arguments.length !== 1)
+            throw new Error(ErrorMessages.NO_INPUT_VALUE);
+
+        // GET TYPE INFO
+        const type: ts.Type =
+            expression.typeArguments && expression.typeArguments[0]
+                ? project.checker.getTypeFromTypeNode(
+                      expression.typeArguments[0],
+                  )
+                : project.checker.getTypeAtLocation(expression.arguments[0]!);
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+
+        // DO TRANSFORM
+        return ts.factory.createCallExpression(
+            AssertPruneProgrammer.generate(project, modulo)(type),
+            undefined,
+            [expression.arguments[0]!],
+        );
+    }
+}
+
+const enum ErrorMessages {
+    NO_INPUT_VALUE = "Error on typia.assertPrune(): no input value.",
+    GENERIC_ARGUMENT = "Error on typia.assertPrune(): non-specified generic argument.",
+}

package/src/transformers/features/miscellaneous/CreateAssertPruneTransformer.ts

@@ -0,0 +1,32 @@
+import ts from "typescript";
+
+import { AssertPruneProgrammer } from "../../../programmers/AssertPruneProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace CreateAssertPruneTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        // CHECK GENERIC ARGUMENT EXISTENCE
+        if (!expression.typeArguments || !expression.typeArguments[0])
+            throw new Error(ErrorMessages.NOT_SPECIFIED);
+
+        // GET TYPE INFO
+        const type: ts.Type = project.checker.getTypeFromTypeNode(
+            expression.typeArguments[0],
+        );
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+
+        // DO TRANSFORM
+        return AssertPruneProgrammer.generate(project, modulo)(type);
+    }
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.assertPrune(): generic argument is not specified.",
+    GENERIC_ARGUMENT = "Error on typia.assertPrune(): non-specified generic argument.",
+}