@nestia/core 3.0.0-dev.20231209 → 3.0.0

package/src/programmers/http/HttpAssertQuerifyProgrammer.ts

@@ -1,58 +1,58 @@
-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 { IProject } from "typia/lib/transformers/IProject";
-
-import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
-
-export namespace HttpAssertQuerifyProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.ArrowFunction =>
-      ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [IdentifierFactory.parameter("input")],
-        undefined,
-        undefined,
-        ts.factory.createBlock([
-          StatementFactory.constant(
-            "assert",
-            AssertProgrammer.write({
-              ...project,
-              options: {
-                ...project.options,
-                functional: false,
-                numeric: false,
-              },
-            })(modulo)(false)(type, name),
-          ),
-          StatementFactory.constant(
-            "stringify",
-            HttpQuerifyProgrammer.write({
-              ...project,
-              options: {
-                ...project.options,
-                functional: false,
-                numeric: false,
-              },
-            })(modulo)(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 { IProject } from "typia/lib/transformers/IProject";
+
+import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
+
+export namespace HttpAssertQuerifyProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type, name?: string): ts.ArrowFunction =>
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [IdentifierFactory.parameter("input")],
+        undefined,
+        undefined,
+        ts.factory.createBlock([
+          StatementFactory.constant(
+            "assert",
+            AssertProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(false)(type, name),
+          ),
+          StatementFactory.constant(
+            "stringify",
+            HttpQuerifyProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(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,62 +1,62 @@
-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 { IProject } from "typia/lib/transformers/IProject";
-
-import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
-
-export namespace HttpIsQuerifyProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type): ts.ArrowFunction =>
-      ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [IdentifierFactory.parameter("input")],
-        undefined,
-        undefined,
-        ts.factory.createBlock([
-          StatementFactory.constant(
-            "is",
-            IsProgrammer.write({
-              ...project,
-              options: {
-                ...project.options,
-                functional: false,
-                numeric: false,
-              },
-            })(modulo)(false)(type),
-          ),
-          StatementFactory.constant(
-            "stringify",
-            HttpQuerifyProgrammer.write({
-              ...project,
-              options: {
-                ...project.options,
-                functional: false,
-                numeric: false,
-              },
-            })(modulo)(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 { IProject } from "typia/lib/transformers/IProject";
+
+import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
+
+export namespace HttpIsQuerifyProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type): ts.ArrowFunction =>
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [IdentifierFactory.parameter("input")],
+        undefined,
+        undefined,
+        ts.factory.createBlock([
+          StatementFactory.constant(
+            "is",
+            IsProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(false)(type),
+          ),
+          StatementFactory.constant(
+            "stringify",
+            HttpQuerifyProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(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,96 +1,96 @@
-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 { FunctionImporter } from "typia/lib/programmers/helpers/FunctionImporeter";
-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 { IProject } from "typia/lib/transformers/IProject";
-import { TransformerError } from "typia/lib/transformers/TransformerError";
-
-export namespace HttpQuerifyProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type): ts.ArrowFunction => {
-      // GET OBJECT TYPE
-      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const collection: MetadataCollection = new MetadataCollection();
-      const result = MetadataFactory.analyze(project.checker)({
-        escape: false,
-        constant: true,
-        absorb: true,
-        validate: HttpQueryProgrammer.validate,
-      })(collection)(type);
-      if (result.success === false)
-        throw TransformerError.from(
-          `@nestia.core.TypedQuery.${importer.method}`,
-        )(result.errors);
-
-      const object: MetadataObject = result.data.objects[0]!;
-      return ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [IdentifierFactory.parameter("input")],
-        undefined,
-        undefined,
-        ts.factory.createBlock(
-          [
-            ...importer.declare(modulo),
-            StatementFactory.constant(
-              "output",
-              ts.factory.createNewExpression(
-                ts.factory.createIdentifier("URLSearchParams"),
-                undefined,
-                [],
-              ),
-            ),
-            ...object.properties.map((p) =>
-              ts.factory.createExpressionStatement(
-                decode(p.key.constants[0]!.values[0] 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 { FunctionImporter } from "typia/lib/programmers/helpers/FunctionImporeter";
+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 { IProject } from "typia/lib/transformers/IProject";
+import { TransformerError } from "typia/lib/transformers/TransformerError";
+
+export namespace HttpQuerifyProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type): ts.ArrowFunction => {
+      // GET OBJECT TYPE
+      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
+      const collection: MetadataCollection = new MetadataCollection();
+      const result = MetadataFactory.analyze(project.checker)({
+        escape: false,
+        constant: true,
+        absorb: true,
+        validate: HttpQueryProgrammer.validate,
+      })(collection)(type);
+      if (result.success === false)
+        throw TransformerError.from(
+          `nestia.core.TypedQuery.${importer.method}`,
+        )(result.errors);
+
+      const object: MetadataObject = result.data.objects[0]!;
+      return ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [IdentifierFactory.parameter("input")],
+        undefined,
+        undefined,
+        ts.factory.createBlock(
+          [
+            ...importer.declare(modulo),
+            StatementFactory.constant(
+              "output",
+              ts.factory.createNewExpression(
+                ts.factory.createIdentifier("URLSearchParams"),
+                undefined,
+                [],
+              ),
+            ),
+            ...object.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],
+    );
+}

package/src/programmers/http/HttpValidateQuerifyProgrammer.ts

@@ -1,63 +1,63 @@
-import ts from "typescript";
-import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
-import { StatementFactory } from "typia/lib/factories/StatementFactory";
-import { ValidateProgrammer } from "typia/lib/programmers/ValidateProgrammer";
-import { IProject } from "typia/lib/transformers/IProject";
-
-import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
-
-export namespace HttpValidateQuerifyProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.ArrowFunction =>
-      ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [IdentifierFactory.parameter("input")],
-        undefined,
-        undefined,
-        ts.factory.createBlock([
-          StatementFactory.constant(
-            "validate",
-            ValidateProgrammer.write({
-              ...project,
-              options: {
-                ...project.options,
-                functional: false,
-                numeric: true,
-              },
-            })(modulo)(false)(type, name),
-          ),
-          StatementFactory.constant(
-            "query",
-            HttpQuerifyProgrammer.write({
-              ...project,
-              options: {
-                ...project.options,
-                functional: false,
-                numeric: false,
-              },
-            })(modulo)(type),
-          ),
-          StatementFactory.constant(
-            "output",
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("query"),
-              undefined,
-              [ts.factory.createIdentifier("input")],
-            ),
-          ),
-          ts.factory.createReturnStatement(
-            ts.factory.createAsExpression(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("validate"),
-                undefined,
-                [ts.factory.createIdentifier("output")],
-              ),
-              ts.factory.createTypeReferenceNode("any"),
-            ),
-          ),
-        ]),
-      );
-}
+import ts from "typescript";
+import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
+import { StatementFactory } from "typia/lib/factories/StatementFactory";
+import { ValidateProgrammer } from "typia/lib/programmers/ValidateProgrammer";
+import { IProject } from "typia/lib/transformers/IProject";
+
+import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
+
+export namespace HttpValidateQuerifyProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type, name?: string): ts.ArrowFunction =>
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [IdentifierFactory.parameter("input")],
+        undefined,
+        undefined,
+        ts.factory.createBlock([
+          StatementFactory.constant(
+            "validate",
+            ValidateProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: true,
+              },
+            })(modulo)(false)(type, name),
+          ),
+          StatementFactory.constant(
+            "query",
+            HttpQuerifyProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(type),
+          ),
+          StatementFactory.constant(
+            "output",
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("query"),
+              undefined,
+              [ts.factory.createIdentifier("input")],
+            ),
+          ),
+          ts.factory.createReturnStatement(
+            ts.factory.createAsExpression(
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("validate"),
+                undefined,
+                [ts.factory.createIdentifier("output")],
+              ),
+              ts.factory.createTypeReferenceNode("any"),
+            ),
+          ),
+        ]),
+      );
+}

package/src/programmers/internal/CoreMetadataUtil.ts

@@ -1,21 +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;
-}
+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;
+}