@nestia/core 4.2.0-dev.20241211 → 4.2.0

package/src/programmers/TypedRouteProgrammer.ts

@@ -1,76 +1,76 @@
-import ts from "typescript";
-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 { IProgrammerProps } from "typia/lib/transformers/IProgrammerProps";
-
-import { INestiaTransformContext } from "../options/INestiaTransformProject";
-
-export namespace TypedRouteProgrammer {
-  export const generate = (props: {
-    context: INestiaTransformContext;
-    modulo: ts.LeftHandSideExpression;
-    type: ts.Type;
-  }): ts.Expression => {
-    // GENERATE STRINGIFY PLAN
-    const parameter = (next: {
-      type: string;
-      key: string;
-      programmer: (next: IProgrammerProps) => ts.Expression;
-    }) =>
-      ts.factory.createObjectLiteralExpression([
-        ts.factory.createPropertyAssignment(
-          ts.factory.createIdentifier("type"),
-          ts.factory.createStringLiteral(next.type),
-        ),
-        ts.factory.createPropertyAssignment(
-          ts.factory.createIdentifier(next.key),
-          next.programmer({
-            context: {
-              ...props.context,
-              options: {}, // use default option
-            },
-            modulo: props.modulo,
-            type: props.type,
-            name: undefined,
-          }),
-        ),
-      ]);
-
-    // RETURNS
-    if (props.context.options.stringify === "is")
-      return parameter({
-        type: "is",
-        key: "is",
-        programmer: JsonIsStringifyProgrammer.write,
-      });
-    else if (props.context.options.stringify === "validate")
-      return parameter({
-        type: "validate",
-        key: "validate",
-        programmer: JsonValidateStringifyProgrammer.write,
-      });
-    else if (props.context.options.stringify === "stringify")
-      return parameter({
-        type: "stringify",
-        key: "stringify",
-        programmer: JsonStringifyProgrammer.write,
-      });
-    else if (props.context.options.stringify === "validate.log")
-      return parameter({
-        type: "validate.log",
-        key: "validate",
-        programmer: JsonValidateStringifyProgrammer.write,
-      });
-    else if (props.context.options.stringify === null)
-      return ts.factory.createNull();
-
-    // ASSERT IS DEFAULT
-    return parameter({
-      type: "assert",
-      key: "assert",
-      programmer: JsonAssertStringifyProgrammer.write,
-    });
-  };
-}
+import ts from "typescript";
+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 { IProgrammerProps } from "typia/lib/transformers/IProgrammerProps";
+
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
+
+export namespace TypedRouteProgrammer {
+  export const generate = (props: {
+    context: INestiaTransformContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.Expression => {
+    // GENERATE STRINGIFY PLAN
+    const parameter = (next: {
+      type: string;
+      key: string;
+      programmer: (next: IProgrammerProps) => ts.Expression;
+    }) =>
+      ts.factory.createObjectLiteralExpression([
+        ts.factory.createPropertyAssignment(
+          ts.factory.createIdentifier("type"),
+          ts.factory.createStringLiteral(next.type),
+        ),
+        ts.factory.createPropertyAssignment(
+          ts.factory.createIdentifier(next.key),
+          next.programmer({
+            context: {
+              ...props.context,
+              options: {}, // use default option
+            },
+            modulo: props.modulo,
+            type: props.type,
+            name: undefined,
+          }),
+        ),
+      ]);
+
+    // RETURNS
+    if (props.context.options.stringify === "is")
+      return parameter({
+        type: "is",
+        key: "is",
+        programmer: JsonIsStringifyProgrammer.write,
+      });
+    else if (props.context.options.stringify === "validate")
+      return parameter({
+        type: "validate",
+        key: "validate",
+        programmer: JsonValidateStringifyProgrammer.write,
+      });
+    else if (props.context.options.stringify === "stringify")
+      return parameter({
+        type: "stringify",
+        key: "stringify",
+        programmer: JsonStringifyProgrammer.write,
+      });
+    else if (props.context.options.stringify === "validate.log")
+      return parameter({
+        type: "validate.log",
+        key: "validate",
+        programmer: JsonValidateStringifyProgrammer.write,
+      });
+    else if (props.context.options.stringify === null)
+      return ts.factory.createNull();
+
+    // ASSERT IS DEFAULT
+    return parameter({
+      type: "assert",
+      key: "assert",
+      programmer: JsonAssertStringifyProgrammer.write,
+    });
+  };
+}

package/src/programmers/http/HttpAssertQuerifyProgrammer.ts

@@ -1,72 +1,72 @@
-import ts from "typescript";
-import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
-import { StatementFactory } from "typia/lib/factories/StatementFactory";
-import { AssertProgrammer } from "typia/lib/programmers/AssertProgrammer";
-import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
-
-import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
-
-export namespace HttpAssertQuerifyProgrammer {
-  export const write = (props: {
-    context: ITypiaContext;
-    modulo: ts.LeftHandSideExpression;
-    type: ts.Type;
-  }): ts.ArrowFunction =>
-    ts.factory.createArrowFunction(
-      undefined,
-      undefined,
-      [IdentifierFactory.parameter("input")],
-      undefined,
-      undefined,
-      ts.factory.createBlock([
-        StatementFactory.constant({
-          name: "assert",
-          value: AssertProgrammer.write({
-            context: {
-              ...props.context,
-              options: {
-                ...props.context.options,
-                functional: false,
-                numeric: false,
-              },
-            },
-            modulo: props.modulo,
-            config: {
-              equals: false,
-              guard: false,
-            },
-            type: props.type,
-            name: undefined,
-          }),
-        }),
-        StatementFactory.constant({
-          name: "stringify",
-          value: HttpQuerifyProgrammer.write({
-            context: {
-              ...props.context,
-              options: {
-                ...props.context.options,
-                functional: false,
-                numeric: false,
-              },
-            },
-            modulo: props.modulo,
-            type: props.type,
-          }),
-        }),
-        ts.factory.createReturnStatement(
-          ts.factory.createCallExpression(
-            ts.factory.createIdentifier("stringify"),
-            undefined,
-            [
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("assert"),
-                undefined,
-                [ts.factory.createIdentifier("input")],
-              ),
-            ],
-          ),
-        ),
-      ]),
-    );
-}
+import ts from "typescript";
+import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
+import { StatementFactory } from "typia/lib/factories/StatementFactory";
+import { AssertProgrammer } from "typia/lib/programmers/AssertProgrammer";
+import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
+
+import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
+
+export namespace HttpAssertQuerifyProgrammer {
+  export const write = (props: {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.ArrowFunction =>
+    ts.factory.createArrowFunction(
+      undefined,
+      undefined,
+      [IdentifierFactory.parameter("input")],
+      undefined,
+      undefined,
+      ts.factory.createBlock([
+        StatementFactory.constant({
+          name: "assert",
+          value: AssertProgrammer.write({
+            context: {
+              ...props.context,
+              options: {
+                ...props.context.options,
+                functional: false,
+                numeric: false,
+              },
+            },
+            modulo: props.modulo,
+            config: {
+              equals: false,
+              guard: false,
+            },
+            type: props.type,
+            name: undefined,
+          }),
+        }),
+        StatementFactory.constant({
+          name: "stringify",
+          value: HttpQuerifyProgrammer.write({
+            context: {
+              ...props.context,
+              options: {
+                ...props.context.options,
+                functional: false,
+                numeric: false,
+              },
+            },
+            modulo: props.modulo,
+            type: props.type,
+          }),
+        }),
+        ts.factory.createReturnStatement(
+          ts.factory.createCallExpression(
+            ts.factory.createIdentifier("stringify"),
+            undefined,
+            [
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("assert"),
+                undefined,
+                [ts.factory.createIdentifier("input")],
+              ),
+            ],
+          ),
+        ),
+      ]),
+    );
+}

package/src/programmers/http/HttpIsQuerifyProgrammer.ts

@@ -1,75 +1,75 @@
-import ts from "typescript";
-import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
-import { StatementFactory } from "typia/lib/factories/StatementFactory";
-import { IsProgrammer } from "typia/lib/programmers/IsProgrammer";
-import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
-
-import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
-
-export namespace HttpIsQuerifyProgrammer {
-  export const write = (props: {
-    context: ITypiaContext;
-    modulo: ts.LeftHandSideExpression;
-    type: ts.Type;
-  }): ts.ArrowFunction =>
-    ts.factory.createArrowFunction(
-      undefined,
-      undefined,
-      [IdentifierFactory.parameter("input")],
-      undefined,
-      undefined,
-      ts.factory.createBlock([
-        StatementFactory.constant({
-          name: "is",
-          value: IsProgrammer.write({
-            config: {
-              equals: false,
-            },
-            context: {
-              ...props.context,
-              options: {
-                ...props.context.options,
-                functional: false,
-                numeric: false,
-              },
-            },
-            modulo: props.modulo,
-            type: props.type,
-            name: undefined,
-          }),
-        }),
-        StatementFactory.constant({
-          name: "stringify",
-          value: HttpQuerifyProgrammer.write({
-            context: {
-              ...props.context,
-              options: {
-                ...props.context.options,
-                functional: false,
-                numeric: false,
-              },
-            },
-            modulo: props.modulo,
-            type: props.type,
-          }),
-        }),
-        ts.factory.createReturnStatement(
-          ts.factory.createConditionalExpression(
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("is"),
-              undefined,
-              [ts.factory.createIdentifier("input")],
-            ),
-            undefined,
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("stringify"),
-              undefined,
-              [ts.factory.createIdentifier("input")],
-            ),
-            undefined,
-            ts.factory.createNull(),
-          ),
-        ),
-      ]),
-    );
-}
+import ts from "typescript";
+import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
+import { StatementFactory } from "typia/lib/factories/StatementFactory";
+import { IsProgrammer } from "typia/lib/programmers/IsProgrammer";
+import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
+
+import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
+
+export namespace HttpIsQuerifyProgrammer {
+  export const write = (props: {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.ArrowFunction =>
+    ts.factory.createArrowFunction(
+      undefined,
+      undefined,
+      [IdentifierFactory.parameter("input")],
+      undefined,
+      undefined,
+      ts.factory.createBlock([
+        StatementFactory.constant({
+          name: "is",
+          value: IsProgrammer.write({
+            config: {
+              equals: false,
+            },
+            context: {
+              ...props.context,
+              options: {
+                ...props.context.options,
+                functional: false,
+                numeric: false,
+              },
+            },
+            modulo: props.modulo,
+            type: props.type,
+            name: undefined,
+          }),
+        }),
+        StatementFactory.constant({
+          name: "stringify",
+          value: HttpQuerifyProgrammer.write({
+            context: {
+              ...props.context,
+              options: {
+                ...props.context.options,
+                functional: false,
+                numeric: false,
+              },
+            },
+            modulo: props.modulo,
+            type: props.type,
+          }),
+        }),
+        ts.factory.createReturnStatement(
+          ts.factory.createConditionalExpression(
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("is"),
+              undefined,
+              [ts.factory.createIdentifier("input")],
+            ),
+            undefined,
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("stringify"),
+              undefined,
+              [ts.factory.createIdentifier("input")],
+            ),
+            undefined,
+            ts.factory.createNull(),
+          ),
+        ),
+      ]),
+    );
+}

package/src/programmers/http/HttpQuerifyProgrammer.ts

@@ -1,108 +1,108 @@
-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 { StatementFactory } from "typia/lib/factories/StatementFactory";
-import { FunctionProgrammer } from "typia/lib/programmers/helpers/FunctionProgrammer";
-import { HttpQueryProgrammer } from "typia/lib/programmers/http/HttpQueryProgrammer";
-import { Metadata } from "typia/lib/schemas/metadata/Metadata";
-import { MetadataObject } from "typia/lib/schemas/metadata/MetadataObject";
-import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
-import { TransformerError } from "typia/lib/transformers/TransformerError";
-
-export namespace HttpQuerifyProgrammer {
-  export const write = (props: {
-    context: ITypiaContext;
-    modulo: ts.LeftHandSideExpression;
-    type: ts.Type;
-  }): ts.ArrowFunction => {
-    // GET OBJECT TYPE
-    const functor: FunctionProgrammer = new FunctionProgrammer(
-      props.modulo.getText(),
-    );
-    const collection: MetadataCollection = new MetadataCollection();
-    const result = MetadataFactory.analyze({
-      checker: props.context.checker,
-      transformer: props.context.transformer,
-      options: {
-        escape: false,
-        constant: true,
-        absorb: true,
-        validate: HttpQueryProgrammer.validate,
-      },
-      type: props.type,
-      collection,
-    });
-    if (result.success === false)
-      throw TransformerError.from({
-        code: functor.method,
-        errors: result.errors,
-      });
-
-    const object: MetadataObject = result.data.objects[0]!;
-    return ts.factory.createArrowFunction(
-      undefined,
-      undefined,
-      [IdentifierFactory.parameter("input")],
-      undefined,
-      undefined,
-      ts.factory.createBlock(
-        [
-          ...functor.declare(),
-          StatementFactory.constant({
-            name: "output",
-            value: ts.factory.createNewExpression(
-              ts.factory.createIdentifier("URLSearchParams"),
-              undefined,
-              [],
-            ),
-          }),
-          ...object.type.properties.map((p) =>
-            ts.factory.createExpressionStatement(
-              decode(p.key.constants[0]!.values[0].value as string)(p.value),
-            ),
-          ),
-          ts.factory.createReturnStatement(
-            ts.factory.createIdentifier("output"),
-          ),
-        ],
-        true,
-      ),
-    );
-  };
-
-  const decode =
-    (key: string) =>
-    (value: Metadata): ts.CallExpression =>
-      !!value.arrays.length
-        ? ts.factory.createCallExpression(
-            IdentifierFactory.access(
-              IdentifierFactory.access(
-                ts.factory.createIdentifier("input"),
-                key,
-              ),
-              "forEach",
-            ),
-            undefined,
-            [
-              ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [IdentifierFactory.parameter("elem")],
-                undefined,
-                undefined,
-                append(key)(ts.factory.createIdentifier("elem")),
-              ),
-            ],
-          )
-        : append(key)(
-            IdentifierFactory.access(ts.factory.createIdentifier("input"), key),
-          );
-
-  const append = (key: string) => (elem: ts.Expression) =>
-    ts.factory.createCallExpression(
-      IdentifierFactory.access(ts.factory.createIdentifier("output"), "append"),
-      undefined,
-      [ts.factory.createStringLiteral(key), elem],
-    );
-}
+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 { StatementFactory } from "typia/lib/factories/StatementFactory";
+import { FunctionProgrammer } from "typia/lib/programmers/helpers/FunctionProgrammer";
+import { HttpQueryProgrammer } from "typia/lib/programmers/http/HttpQueryProgrammer";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+import { MetadataObject } from "typia/lib/schemas/metadata/MetadataObject";
+import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
+import { TransformerError } from "typia/lib/transformers/TransformerError";
+
+export namespace HttpQuerifyProgrammer {
+  export const write = (props: {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.ArrowFunction => {
+    // GET OBJECT TYPE
+    const functor: FunctionProgrammer = new FunctionProgrammer(
+      props.modulo.getText(),
+    );
+    const collection: MetadataCollection = new MetadataCollection();
+    const result = MetadataFactory.analyze({
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      options: {
+        escape: false,
+        constant: true,
+        absorb: true,
+        validate: HttpQueryProgrammer.validate,
+      },
+      type: props.type,
+      collection,
+    });
+    if (result.success === false)
+      throw TransformerError.from({
+        code: functor.method,
+        errors: result.errors,
+      });
+
+    const object: MetadataObject = result.data.objects[0]!;
+    return ts.factory.createArrowFunction(
+      undefined,
+      undefined,
+      [IdentifierFactory.parameter("input")],
+      undefined,
+      undefined,
+      ts.factory.createBlock(
+        [
+          ...functor.declare(),
+          StatementFactory.constant({
+            name: "output",
+            value: ts.factory.createNewExpression(
+              ts.factory.createIdentifier("URLSearchParams"),
+              undefined,
+              [],
+            ),
+          }),
+          ...object.type.properties.map((p) =>
+            ts.factory.createExpressionStatement(
+              decode(p.key.constants[0]!.values[0].value as string)(p.value),
+            ),
+          ),
+          ts.factory.createReturnStatement(
+            ts.factory.createIdentifier("output"),
+          ),
+        ],
+        true,
+      ),
+    );
+  };
+
+  const decode =
+    (key: string) =>
+    (value: Metadata): ts.CallExpression =>
+      !!value.arrays.length
+        ? ts.factory.createCallExpression(
+            IdentifierFactory.access(
+              IdentifierFactory.access(
+                ts.factory.createIdentifier("input"),
+                key,
+              ),
+              "forEach",
+            ),
+            undefined,
+            [
+              ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [IdentifierFactory.parameter("elem")],
+                undefined,
+                undefined,
+                append(key)(ts.factory.createIdentifier("elem")),
+              ),
+            ],
+          )
+        : append(key)(
+            IdentifierFactory.access(ts.factory.createIdentifier("input"), key),
+          );
+
+  const append = (key: string) => (elem: ts.Expression) =>
+    ts.factory.createCallExpression(
+      IdentifierFactory.access(ts.factory.createIdentifier("output"), "append"),
+      undefined,
+      [ts.factory.createStringLiteral(key), elem],
+    );
+}