@nestia/core 2.0.0-dev.20230831-5 → 2.0.0-dev.20230831-6

package/src/programmers/TypedParamProgrammer.ts

@@ -1,101 +1,135 @@
 import ts from "typescript";
 
+import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
 import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
 import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
-import { Metadata } from "typia/lib/metadata/Metadata";
+import { IsProgrammer } from "typia/lib/programmers/IsProgrammer";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+import { TransformerError } from "typia/lib/transformers/TransformerError";
 
 import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { CoreMetadataUtil } from "./internal/CoreMetadataUtil";
 
 export namespace TypedParamProgrammer {
     export const generate =
-        ({ checker }: INestiaTransformProject) =>
+        (project: INestiaTransformProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
         (parameters: readonly ts.Expression[]) =>
         (type: ts.Type): readonly ts.Expression[] => {
-            const metadata: Metadata = MetadataFactory.analyze(checker)({
-                resolve: false,
-                constant: true,
-                absorb: true,
-            })(new MetadataCollection())(type);
-            validate(metadata);
-            const [atomic] = get_atomic_types(metadata);
-
-            // AUTO TYPE SPECIFICATION
-            if (parameters.length === 1)
-                return [
-                    parameters[0],
-                    ts.factory.createStringLiteral(atomic),
-                    metadata.nullable
-                        ? ts.factory.createTrue()
-                        : ts.factory.createFalse(),
-                ];
+            // ALREADY BEING TRANSFORMED
+            if (parameters.length !== 1) return parameters;
 
-            // TYPE HAS BEEN SPECIFIED IN DECORATOR
-            const specified: Metadata = MetadataFactory.analyze(checker)({
-                resolve: false,
+            const result = MetadataFactory.analyze(project.checker)({
+                escape: false,
                 constant: true,
                 absorb: true,
-            })(new MetadataCollection())(
-                checker.getTypeAtLocation(parameters[1]),
-            );
-            if (equals(atomic, specified) === false)
-                throw error("different type between parameter and variable");
-
-            if (parameters.length === 2)
-                return [
-                    parameters[0],
-                    parameters[1],
-                    metadata.nullable
-                        ? ts.factory.createTrue()
-                        : ts.factory.createFalse(),
-                ];
-
-            // NULLABLE HAS BEEN SPECIFIED
-            const nullable: Metadata = MetadataFactory.analyze(checker)({
-                resolve: false,
-                constant: true,
-                absorb: true,
-            })(new MetadataCollection())(
-                checker.getTypeAtLocation(parameters[2]),
-            );
-            if (nullable.getName() !== "true" && nullable.getName() !== "false")
-                throw error("nullable value must be literal type");
-            else if (metadata.nullable !== (nullable.getName() === "true"))
-                throw error(
-                    "different type (nullable) between parameter and variable",
+                validate,
+            })(new MetadataCollection())(type);
+            if (result.success === false)
+                throw TransformerError.from("@core.nestia.TypedParam")(
+                    result.errors,
                 );
-            return parameters;
+            const [atomic] = [...CoreMetadataUtil.atomics(result.data)];
+            const name: string = result.data.getName();
+            const is: ts.ArrowFunction = IsProgrammer.write({
+                ...project,
+                options: {
+                    numeric: true,
+                },
+            })(modulo)(false)(type);
+            const cast: ts.ArrowFunction = CASTERS[atomic]();
+
+            return [
+                parameters[0],
+                ts.factory.createObjectLiteralExpression(
+                    [
+                        ts.factory.createPropertyAssignment(
+                            "name",
+                            ts.factory.createIdentifier(name),
+                        ),
+                        ts.factory.createPropertyAssignment("is", is),
+                        ts.factory.createPropertyAssignment("cast", cast),
+                    ],
+                    true,
+                ),
+            ];
         };
-}
 
-const validate = (meta: Metadata) => {
-    if (meta.any) throw error("do not allow any type");
-    else if (meta.isRequired() === false)
-        throw error("do not allow undefindable type");
+    export const validate = (meta: Metadata): string[] => {
+        const errors: string[] = [];
+        const insert = (msg: string) => errors.push(msg);
 
-    const atomics: string[] = get_atomic_types(meta);
-    const expected: number =
-        meta.atomics.length +
-        meta.templates.length +
-        meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0);
-    if (meta.size() !== expected || atomics.length === 0)
-        throw error("only atomic or constant types is allowed");
-    else if (atomics.length > 1) throw error("do not allow union type");
-};
+        if (meta.any) insert("do not allow any type");
+        if (meta.isRequired() === false)
+            insert("do not allow undefindable type");
 
-const get_atomic_types = (meta: Metadata): string[] => [
-    ...new Set([
-        ...meta.atomics,
-        ...meta.constants.map((c) => c.type),
-        ...(meta.templates.length ? ["string"] : []),
-    ]),
-];
+        const atomics = CoreMetadataUtil.atomics(meta);
+        const expected: number =
+            meta.atomics.length +
+            meta.templates.length +
+            meta.constants
+                .map((c) => c.values.length)
+                .reduce((a, b) => a + b, 0);
+        if (meta.size() !== expected || atomics.size === 0)
+            insert("only atomic or constant types are allowed");
+        if (atomics.size > 1) insert("do not allow union type");
 
-const error = (message: string) =>
-    new Error(`Error on nestia.core.TypedParam(): ${message}.`);
+        return errors;
+    };
+}
 
-const equals = (atomic: string, p: Metadata) => {
-    const name: string = p.getName();
-    if (atomic === "string")
-        return name === `"string"` || name === `"uuid"` || name === `"date"`;
-    return `"${atomic}"` === name;
+const CASTERS = {
+    boolean: () =>
+        ts.factory.createArrowFunction(
+            undefined,
+            undefined,
+            [IdentifierFactory.parameter("str")],
+            undefined,
+            undefined,
+            ts.factory.createLogicalOr(
+                ts.factory.createStrictEquality(
+                    ts.factory.createStringLiteral("true"),
+                    ts.factory.createIdentifier("str"),
+                ),
+                ts.factory.createStrictEquality(
+                    ts.factory.createStringLiteral("1"),
+                    ts.factory.createIdentifier("str"),
+                ),
+            ),
+        ),
+    number: () =>
+        ts.factory.createArrowFunction(
+            undefined,
+            undefined,
+            [IdentifierFactory.parameter("str")],
+            undefined,
+            undefined,
+            ts.factory.createCallExpression(
+                ts.factory.createIdentifier("Number"),
+                undefined,
+                [ts.factory.createIdentifier("str")],
+            ),
+        ),
+    bigint: () =>
+        ts.factory.createArrowFunction(
+            undefined,
+            undefined,
+            [IdentifierFactory.parameter("str")],
+            undefined,
+            undefined,
+            ts.factory.createCallExpression(
+                ts.factory.createIdentifier("BigInt"),
+                undefined,
+                [ts.factory.createIdentifier("str")],
+            ),
+        ),
+    string: () =>
+        ts.factory.createArrowFunction(
+            undefined,
+            undefined,
+            [IdentifierFactory.parameter("str")],
+            undefined,
+            undefined,
+            ts.factory.createIdentifier("str"),
+        ),
 };

package/src/programmers/TypedQueryProgrammer.ts

@@ -4,15 +4,18 @@ import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
 import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
 import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
 import { StatementFactory } from "typia/lib/factories/StatementFactory";
-import { Metadata } from "typia/lib/metadata/Metadata";
-import { MetadataObject } from "typia/lib/metadata/MetadataObject";
-import { MetadataProperty } from "typia/lib/metadata/MetadataProperty";
 import { AssertProgrammer } from "typia/lib/programmers/AssertProgrammer";
 import { FunctionImporter } from "typia/lib/programmers/helpers/FunctionImporeter";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+import { MetadataArray } from "typia/lib/schemas/metadata/MetadataArray";
+import { MetadataObject } from "typia/lib/schemas/metadata/MetadataObject";
+import { MetadataProperty } from "typia/lib/schemas/metadata/MetadataProperty";
+import { TransformerError } from "typia/lib/transformers/TransformerError";
 import { Atomic } from "typia/lib/typings/Atomic";
 import { Escaper } from "typia/lib/utils/Escaper";
 
 import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { CoreMetadataUtil } from "./internal/CoreMetadataUtil";
 
 export namespace TypedQueryProgrammer {
     export const generate =
@@ -23,107 +26,95 @@ export namespace TypedQueryProgrammer {
             return decode(project, modulo)(type, object);
         };
 
+    export const validate = (
+        meta: Metadata,
+        explore: MetadataFactory.IExplore,
+    ): string[] => {
+        const errors: string[] = [];
+        const insert = (msg: string) => errors.push(msg);
+
+        if (explore.top === true) {
+            // TOP MUST BE ONLY OBJECT
+            if (meta.objects.length !== 1 || meta.bucket() !== 1)
+                insert("only one object type is allowed.");
+            if (meta.nullable === true)
+                insert("query parameters cannot be null.");
+            if (meta.isRequired() === false)
+                insert("query parameters cannot be undefined.");
+        } else if (
+            explore.nested !== null &&
+            explore.nested instanceof MetadataArray
+        ) {
+            const atomics = CoreMetadataUtil.atomics(meta);
+            const expected: number =
+                meta.atomics.length +
+                meta.templates.length +
+                meta.constants
+                    .map((c) => c.values.length)
+                    .reduce((a, b) => a + b, 0);
+            if (atomics.size > 1) insert("union type is not allowed in array.");
+            if (meta.nullable) insert("nullable type is not allowed in array.");
+            if (meta.isRequired() === false)
+                insert("optional type is not allowed in array.");
+            if (meta.size() !== expected)
+                insert("only atomic or constant types are allowed in array.");
+        } else if (explore.object && explore.property !== null) {
+            //----
+            // COMMON
+            //----
+            // PROPERTY MUST BE SOLE
+            if (typeof explore.property === "object")
+                insert("dynamic property is not allowed.");
+            // MUST BE LOWER-CASE
+            if (
+                typeof explore.property === "string" &&
+                explore.property !== explore.property.toLowerCase()
+            )
+                insert("property name must be lower-case.");
+            // DO NOT ALLOW TUPLE TYPE
+            if (meta.tuples.length) insert("tuple type is not allowed.");
+            // DO NOT ALLOW UNION TYPE
+            if (CoreMetadataUtil.isUnion(meta))
+                insert("union type is not allowed.");
+            // DO NOT ALLOW NESTED OBJECT
+            if (
+                meta.objects.length ||
+                meta.sets.length ||
+                meta.maps.length ||
+                meta.natives.length
+            )
+                insert("nested object type is not allowed.");
+
+            //----
+            // ARRAY CASES
+            //----
+            const isArray: boolean =
+                meta.arrays.length > 1 || meta.tuples.length > 1;
+            // ARRAY TYPE MUST BE REQUIRED
+            if (isArray && meta.isRequired() === false)
+                insert("optional type is not allowed when array.");
+            // SET-COOKIE MUST BE ARRAY
+            if (explore.property === "set-cookie" && !isArray)
+                insert("set-cookie property must be array.");
+        }
+        return errors;
+    };
+
     const getObject =
         (checker: ts.TypeChecker) =>
         (type: ts.Type): MetadataObject => {
             const collection: MetadataCollection = new MetadataCollection();
-            const metadata: Metadata = MetadataFactory.analyze(checker)({
-                resolve: false,
+            const result = MetadataFactory.analyze(checker)({
+                escape: false,
                 constant: true,
                 absorb: true,
+                validate,
             })(collection)(type);
-            if (metadata.objects.length !== 1 || metadata.bucket() !== 1)
-                throw new Error(
-                    ErrorMessages.object(metadata)(
-                        "only one object type is allowed.",
-                    ),
-                );
-            else if (metadata.nullable === true)
-                throw new Error(
-                    ErrorMessages.object(metadata)(
-                        "query parameter cannot be null.",
-                    ),
-                );
-            else if (metadata.isRequired() === false)
-                throw new Error(
-                    ErrorMessages.object(metadata)(
-                        "query parameter cannot be undefined.",
-                    ),
+            if (result.success === false)
+                throw TransformerError.from("@core.nestia.TypedHeaders")(
+                    result.errors,
                 );
-
-            const object: MetadataObject = metadata.objects[0]!;
-            if (object.properties.some((p) => !(p.key as any).isSoleLiteral()))
-                throw new Error(
-                    ErrorMessages.object(metadata)(
-                        "dynamic property is not allowed.",
-                    ),
-                );
-
-            for (const property of object.properties) {
-                const key: string = property.key.constants[0]
-                    .values[0] as string;
-                const value: Metadata = property.value;
-                validate(object)(key)(value, 0);
-            }
-            return object;
-        };
-
-    const validate =
-        (obj: MetadataObject) =>
-        (key: string) =>
-        (value: Metadata, depth: number): string[] => {
-            if (depth === 1 && value.isRequired() === false)
-                throw new Error(
-                    ErrorMessages.property(obj)(key)(
-                        "optional type is not allowed in array.",
-                    ),
-                );
-            else if (
-                value.maps.length ||
-                value.sets.length ||
-                value.objects.length
-            )
-                throw new Error(
-                    ErrorMessages.property(obj)(key)(
-                        "object type is not allowed",
-                    ),
-                );
-
-            const atom: string[] = [];
-            for (const type of value.atomics) atom.push(type);
-            for (const { type } of value.constants) atom.push(type);
-
-            if (depth === 0 && (value.arrays.length || value.arrays.length)) {
-                if (atom.length)
-                    throw new Error(
-                        ErrorMessages.property(obj)(key)(
-                            "union type is not allowed",
-                        ),
-                    );
-                for (const array of value.arrays)
-                    atom.push(...validate(obj)(key)(array.value, depth + 1));
-                for (const tuple of value.tuples)
-                    for (const elem of tuple.elements)
-                        atom.push(...validate(obj)(key)(elem, depth + 1));
-            } else if (value.arrays.length || value.tuples.length)
-                throw new Error(
-                    ErrorMessages.property(obj)(key)(
-                        "double-array type is not allowed",
-                    ),
-                );
-
-            const size: number = new Set(atom).size;
-            if (size === 0)
-                throw new Error(
-                    ErrorMessages.property(obj)(key)("unknown type"),
-                );
-            else if (size > 1)
-                throw new Error(
-                    ErrorMessages.property(obj)(key)(
-                        "union type is not allowed",
-                    ),
-                );
-            return atom;
+            return result.data.objects[0]!;
         };
 
     const decode =
@@ -150,7 +141,9 @@ export namespace TypedQueryProgrammer {
             })(modulo)(false)(type);
             const output: ts.Identifier = ts.factory.createIdentifier("output");
 
-            const importer: FunctionImporter = new FunctionImporter();
+            const importer: FunctionImporter = new FunctionImporter(
+                "TypedQuery",
+            );
             const optionalArrays: string[] = [];
             const statements: ts.Statement[] = [
                 StatementFactory.constant(
@@ -204,14 +197,15 @@ export namespace TypedQueryProgrammer {
 
             const [type, isArray]: [Atomic.Literal, boolean] = value.atomics
                 .length
-                ? [value.atomics[0], false]
+                ? [value.atomics[0].type, false]
                 : value.constants.length
                 ? [value.constants[0]!.type, false]
                 : (() => {
                       const meta =
-                          value.arrays[0]?.value ?? value.tuples[0].elements[0];
+                          value.arrays[0]?.type.value ??
+                          value.tuples[0].type.elements[0];
                       return meta.atomics.length
-                          ? [meta.atomics[0], true]
+                          ? [meta.atomics[0].type, true]
                           : [meta.constants[0]!.type, true];
                   })();
             return ts.factory.createPropertyAssignment(
@@ -235,13 +229,16 @@ export namespace TypedQueryProgrammer {
                                   [IdentifierFactory.parameter("elem")],
                                   undefined,
                                   undefined,
-                                  decode_value(importer)(type)(
+                                  decode_value(importer)(type)(false)(
                                       ts.factory.createIdentifier("elem"),
                                   ),
                               ),
                           ],
                       )
                     : decode_value(importer)(type)(
+                          value.nullable === false &&
+                              value.isRequired() === false,
+                      )(
                           ts.factory.createCallExpression(
                               ts.factory.createIdentifier("input.get"),
                               undefined,
@@ -254,17 +251,21 @@ export namespace TypedQueryProgrammer {
     const decode_value =
         (importer: FunctionImporter) =>
         (type: Atomic.Literal) =>
-        (value: ts.Expression) =>
-            ts.factory.createCallExpression(importer.use(type), undefined, [
-                value,
-            ]);
-}
-
-namespace ErrorMessages {
-    export const object = (type: Metadata) => (message: string) =>
-        `Error on nestia.core.TypedQuery<${type.getName()}>(): ${message}`;
-
-    export const property =
-        (obj: MetadataObject) => (key: string) => (message: string) =>
-            `Error on nestia.core.TypedQuery<${obj.name}>(): property "${key}" - ${message}`;
+        (onlyUndefindable: boolean) =>
+        (value: ts.Expression) => {
+            const call = ts.factory.createCallExpression(
+                importer.use(type),
+                undefined,
+                [value],
+            );
+            return onlyUndefindable
+                ? ts.factory.createBinaryExpression(
+                      call,
+                      ts.factory.createToken(
+                          ts.SyntaxKind.QuestionQuestionToken,
+                      ),
+                      ts.factory.createIdentifier("undefined"),
+                  )
+                : call;
+        };
 }

package/src/programmers/TypedRouteProgrammer.ts

@@ -1,9 +1,9 @@
 import ts from "typescript";
 
-import { AssertStringifyProgrammer } from "typia/lib/programmers/AssertStringifyProgrammer";
-import { IsStringifyProgrammer } from "typia/lib/programmers/IsStringifyProgrammer";
-import { StringifyProgrammer } from "typia/lib/programmers/StringifyProgrammer";
-import { ValidateStringifyProgrammer } from "typia/lib/programmers/ValidateStringifyProgrammer";
+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 { IProject } from "typia/lib/transformers/IProject";
 
 import { INestiaTransformProject } from "../options/INestiaTransformProject";
@@ -38,15 +38,18 @@ export namespace TypedRouteProgrammer {
 
             // RETURNS
             if (project.options.stringify === "is")
-                return parameter("is", IsStringifyProgrammer.write);
+                return parameter("is", JsonIsStringifyProgrammer.write);
             else if (project.options.stringify === "validate")
-                return parameter("validate", ValidateStringifyProgrammer.write);
+                return parameter(
+                    "validate",
+                    JsonValidateStringifyProgrammer.write,
+                );
             else if (project.options.stringify === "stringify")
-                return parameter("stringify", StringifyProgrammer.write);
+                return parameter("stringify", JsonStringifyProgrammer.write);
             else if (project.options.stringify === null)
                 return ts.factory.createNull();
 
             // ASSERT IS DEFAULT
-            return parameter("assert", AssertStringifyProgrammer.write);
+            return parameter("assert", JsonAssertStringifyProgrammer.write);
         };
 }

package/src/programmers/internal/CoreMetadataUtil.ts

@@ -0,0 +1,21 @@
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+
+export namespace CoreMetadataUtil {
+    export const atomics = (
+        meta: Metadata,
+    ): Set<"boolean" | "bigint" | "number" | "string"> =>
+        new Set([
+            ...meta.atomics.map((a) => a.type),
+            ...meta.constants.map((c) => c.type),
+            ...(meta.templates.length ? (["string"] as const) : []),
+        ]);
+
+    export const isUnion = (meta: Metadata): boolean =>
+        atomics(meta).size +
+            meta.arrays.length +
+            meta.tuples.length +
+            meta.natives.length +
+            meta.maps.length +
+            meta.objects.length >
+        1;
+}

package/src/transform.ts

@@ -1,11 +1,14 @@
 import ts from "typescript";
 
+import { IProject } from "typia/lib/transformers/IProject";
+
 import { INestiaTransformOptions } from "./options/INestiaTransformOptions";
 import { FileTransformer } from "./transformers/FileTransformer";
 
 export const transform = (
     program: ts.Program,
-    options?: INestiaTransformOptions,
+    options: INestiaTransformOptions | undefined,
+    extras: IProject["extras"],
 ): ts.TransformerFactory<ts.SourceFile> => {
     const compilerOptions: ts.CompilerOptions = program.getCompilerOptions();
     const strict: boolean =
@@ -13,15 +16,21 @@ export const transform = (
             ? !!compilerOptions.strictNullChecks
             : !!compilerOptions.strict;
     if (strict === false)
-        throw new Error(
-            `Error on "tsconfig.json": nestia requires \`compilerOptions.strictNullChecks\` to be true.`,
-        );
+        extras.addDiagnostic({
+            category: ts.DiagnosticCategory.Error,
+            code: "(@nestia/core)" as any,
+            file: undefined,
+            start: undefined,
+            length: undefined,
+            messageText: "strict mode is required.",
+        });
     return FileTransformer.transform({
         program,
         compilerOptions,
         checker: program.getTypeChecker(),
         printer: ts.createPrinter(),
-        options: options || {},
+        options: options ?? {},
+        extras,
     });
 };
 export default transform;

package/src/transformers/FileTransformer.ts

@@ -5,12 +5,16 @@ import { NodeTransformer } from "./NodeTransformer";
 
 export namespace FileTransformer {
     export const transform =
-        (project: INestiaTransformProject) =>
+        (project: Omit<INestiaTransformProject, "context">) =>
         (context: ts.TransformationContext) =>
         (file: ts.SourceFile): ts.SourceFile =>
             ts.visitEachChild(
                 file,
-                (node) => iterate_node(project)(context)(node),
+                (node) =>
+                    iterate_node({
+                        ...project,
+                        context,
+                    })(context)(node),
                 context,
             );
 
@@ -27,6 +31,7 @@ export namespace FileTransformer {
     const try_transform_node =
         (project: INestiaTransformProject) =>
         (node: ts.Node): ts.Node => {
+            if (!node) return node;
             try {
                 return NodeTransformer.transform(project)(node);
             } catch (exp) {

package/src/transformers/ParameterDecoratorTransformer.ts

@@ -83,7 +83,8 @@ const FUNCTORS: Record<string, Programmer> = {
         parameters.length
             ? parameters
             : [TypedHeadersProgrammer.generate(project)(modulo)(type)],
-    TypedParam: (project) => () => TypedParamProgrammer.generate(project),
+    TypedParam: (project) => (modulo) =>
+        TypedParamProgrammer.generate(project)(modulo),
     TypedQuery: (project) => (modulo) => (parameters) => (type) =>
         parameters.length
             ? parameters

package/lib/decorators/internal/TransformError.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"TransformError.js","sourceRoot":"","sources":["../../../src/decorators/internal/TransformError.ts"],"names":[],"mappings":";;;AAAA;;GAEG;AACH,SAAgB,cAAc,CAAC,MAAc;IACzC,OAAO,IAAI,KAAK,CACZ,+BAAwB,MAAM,wJAAmJ,CACpL,CAAC;AACN,CAAC;AAJD,wCAIC"}