@nestia/migrate 11.3.0 → 11.3.1

package/src/programmers/NestiaMigrateE2eFileProgrammer.ts

@@ -1,8 +1,15 @@
-import { IdentifierFactory, LiteralFactory } from "@typia/core";
+import {
+  type CallExpression,
+  type FunctionDeclaration,
+  NodeFlags,
+  type Statement,
+  SyntaxKind,
+  factory,
+} from "@ttsc/factory";
 import { IHttpMigrateRoute } from "@typia/interface";
-import ts from "typescript";
 import { OpenApi } from "typia";
 
+import { IdentifierFactory, LiteralFactory } from "../factories";
 import { INestiaMigrateConfig } from "../structures/INestiaMigrateConfig";
 import { NestiaMigrateImportProgrammer } from "./NestiaMigrateImportProgrammer";
 import { NestiaMigrateSchemaProgrammer } from "./NestiaMigrateSchemaProgrammer";
@@ -15,11 +22,11 @@ export namespace NestiaMigrateE2eFunctionProgrammer {
     route: IHttpMigrateRoute;
   }
 
-  export const write = (ctx: IContext): ts.FunctionDeclaration =>
-    ts.factory.createFunctionDeclaration(
+  export const write = (ctx: IContext): FunctionDeclaration =>
+    factory.createFunctionDeclaration(
       [
-        ts.factory.createModifier(ts.SyntaxKind.ExportKeyword),
-        ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword),
+        factory.createModifier(SyntaxKind.ExportKeyword),
+        factory.createModifier(SyntaxKind.AsyncKeyword),
       ],
       undefined,
       ["test", "api", ...ctx.route.accessor].join("_"),
@@ -27,30 +34,30 @@ export namespace NestiaMigrateE2eFunctionProgrammer {
       [
         IdentifierFactory.parameter(
           "connection",
-          ts.factory.createTypeReferenceNode(
-            ts.factory.createQualifiedName(
-              ts.factory.createIdentifier(
+          factory.createTypeReferenceNode(
+            factory.createQualifiedName(
+              factory.createIdentifier(
                 ctx.importer.external({
                   type: "default",
                   library: "@ORGANIZATION/PROJECT-api",
                   name: "api",
                 }),
               ),
-              ts.factory.createIdentifier("IConnection"),
+              factory.createIdentifier("IConnection"),
             ),
           ),
         ),
       ],
       undefined,
-      ts.factory.createBlock(writeBody(ctx), true),
+      factory.createBlock(writeBody(ctx), true),
     );
 
-  export const writeBody = (ctx: IContext): ts.Statement[] => [
-    ts.factory.createVariableStatement(
+  export const writeBody = (ctx: IContext): Statement[] => [
+    factory.createVariableStatement(
       [],
-      ts.factory.createVariableDeclarationList(
+      factory.createVariableDeclarationList(
         [
-          ts.factory.createVariableDeclaration(
+          factory.createVariableDeclaration(
             "output",
             undefined,
             ctx.route.success
@@ -60,16 +67,16 @@ export namespace NestiaMigrateE2eFunctionProgrammer {
                   schema: ctx.route.success.schema,
                 })
               : undefined,
-            ts.factory.createAwaitExpression(writeCallExpressionn(ctx)),
+            factory.createAwaitExpression(writeCallExpressionn(ctx)),
           ),
         ],
-        ts.NodeFlags.Const,
+        NodeFlags.Const,
       ),
     ),
-    ts.factory.createExpressionStatement(
-      ts.factory.createCallExpression(
-        ts.factory.createPropertyAccessExpression(
-          ts.factory.createIdentifier(
+    factory.createExpressionStatement(
+      factory.createCallExpression(
+        factory.createPropertyAccessExpression(
+          factory.createIdentifier(
             ctx.importer.external({
               type: "default",
               library: "typia",
@@ -79,26 +86,26 @@ export namespace NestiaMigrateE2eFunctionProgrammer {
           "assert",
         ),
         undefined,
-        [ts.factory.createIdentifier("output")],
+        [factory.createIdentifier("output")],
       ),
     ),
   ];
 
-  const writeCallExpressionn = (ctx: IContext): ts.CallExpression => {
-    const fetch = ts.factory.createPropertyAccessExpression(
-      ts.factory.createIdentifier("api.functional"),
-      ts.factory.createIdentifier(ctx.route.accessor.join(".")),
+  const writeCallExpressionn = (ctx: IContext): CallExpression => {
+    const fetch = factory.createPropertyAccessExpression(
+      factory.createIdentifier("api.functional"),
+      factory.createIdentifier(ctx.route.accessor.join(".")),
     );
-    const connection = ts.factory.createIdentifier("connection");
+    const connection = factory.createIdentifier("connection");
     if (
       ctx.route.parameters.length === 0 &&
       ctx.route.query === null &&
       ctx.route.body === null
     )
-      return ts.factory.createCallExpression(fetch, undefined, [connection]);
+      return factory.createCallExpression(fetch, undefined, [connection]);
 
-    const random = ts.factory.createPropertyAccessExpression(
-      ts.factory.createIdentifier(
+    const random = factory.createPropertyAccessExpression(
+      factory.createIdentifier(
         ctx.importer.external({
           type: "default",
           library: "typia",
@@ -108,7 +115,7 @@ export namespace NestiaMigrateE2eFunctionProgrammer {
       "random",
     );
     if (ctx.config.keyword === true)
-      return ts.factory.createCallExpression(fetch, undefined, [
+      return factory.createCallExpression(fetch, undefined, [
         connection,
         LiteralFactory.write(
           Object.fromEntries(
@@ -116,7 +123,7 @@ export namespace NestiaMigrateE2eFunctionProgrammer {
               .filter((x) => x !== null)
               .map(({ key, schema: value }) => [
                 key,
-                ts.factory.createCallExpression(
+                factory.createCallExpression(
                   random,
                   [
                     NestiaMigrateSchemaProgrammer.write({
@@ -131,12 +138,12 @@ export namespace NestiaMigrateE2eFunctionProgrammer {
           ),
         ),
       ]);
-    return ts.factory.createCallExpression(fetch, undefined, [
+    return factory.createCallExpression(fetch, undefined, [
       connection,
       ...[...ctx.route.parameters, ctx.route.query, ctx.route.body]
         .filter((p) => !!p)
         .map((p) =>
-          ts.factory.createCallExpression(
+          factory.createCallExpression(
             random,
             [
               NestiaMigrateSchemaProgrammer.write({

package/src/programmers/NestiaMigrateE2eProgrammer.ts

@@ -1,5 +1,5 @@
+import { type FunctionDeclaration, type Statement } from "@ttsc/factory";
 import { IHttpMigrateRoute, OpenApi } from "@typia/interface";
-import ts from "typescript";
 
 import { INestiaMigrateConfig } from "../structures/INestiaMigrateConfig";
 import { INestiaMigrateContext } from "../structures/INestiaMigrateContext";
@@ -25,14 +25,13 @@ export namespace NestiaMigrateE2eProgrammer {
   ): INestiaMigrateFile => {
     const importer: NestiaMigrateImportProgrammer =
       new NestiaMigrateImportProgrammer();
-    const func: ts.FunctionDeclaration =
-      NestiaMigrateE2eFunctionProgrammer.write({
-        config,
-        components,
-        importer,
-        route,
-      });
-    const statements: ts.Statement[] = [
+    const func: FunctionDeclaration = NestiaMigrateE2eFunctionProgrammer.write({
+      config,
+      components,
+      importer,
+      route,
+    });
+    const statements: Statement[] = [
       ...importer.toStatements(
         (name) => `@ORGANIZATION/PROJECT-api/lib/structures/${name}`,
       ),

package/src/programmers/NestiaMigrateImportProgrammer.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import { type Statement, type TypeReferenceNode, factory } from "@ttsc/factory";
 
 import { TypeLiteralFactory } from "../factories/TypeLiteralFactory";
 import { FilePrinter } from "../utils/FilePrinter";
@@ -25,26 +25,26 @@ export class NestiaMigrateImportProgrammer {
     return name;
   }
 
-  public dto(name: string, namespace?: string): ts.TypeReferenceNode {
+  public dto(name: string, namespace?: string): TypeReferenceNode {
     const file: string = name.split(".")[0]!;
     this.dtos_.add(file);
-    return ts.factory.createTypeReferenceNode(
+    return factory.createTypeReferenceNode(
       namespace?.length
-        ? ts.factory.createQualifiedName(
-            ts.factory.createIdentifier(namespace),
-            ts.factory.createIdentifier(file),
+        ? factory.createQualifiedName(
+            factory.createIdentifier(namespace),
+            factory.createIdentifier(file),
           )
         : name,
     );
   }
 
-  public tag(type: string, arg?: any): ts.TypeReferenceNode {
+  public tag(type: string, arg?: any): TypeReferenceNode {
     const instance: string = this.external({
       type: "instance",
       library: "typia",
       name: "tags",
     });
-    return ts.factory.createTypeReferenceNode(
+    return factory.createTypeReferenceNode(
       `${instance}.${type}`,
       arg === undefined ? [] : [TypeLiteralFactory.generate(arg)],
     );
@@ -53,29 +53,29 @@ export class NestiaMigrateImportProgrammer {
   public toStatements(
     dtoPath: (name: string) => string,
     current?: string,
-  ): ts.Statement[] {
+  ): Statement[] {
     return [
       ...[...this.external_.entries()].map(([library, props]) =>
-        ts.factory.createImportDeclaration(
+        factory.createImportDeclaration(
           undefined,
-          ts.factory.createImportClause(
+          factory.createImportClause(
             false,
             props.default !== null
-              ? ts.factory.createIdentifier(props.default)
+              ? factory.createIdentifier(props.default)
               : undefined,
             props.instances.size
-              ? ts.factory.createNamedImports(
+              ? factory.createNamedImports(
                   [...props.instances].map((i) =>
-                    ts.factory.createImportSpecifier(
+                    factory.createImportSpecifier(
                       false,
                       undefined,
-                      ts.factory.createIdentifier(i),
+                      factory.createIdentifier(i),
                     ),
                   ),
                 )
               : undefined,
           ),
-          ts.factory.createStringLiteral(library),
+          factory.createStringLiteral(library),
         ),
       ),
       ...(this.external_.size && this.dtos_.size
@@ -86,20 +86,20 @@ export class NestiaMigrateImportProgrammer {
           current ? (name) => name !== current!.split(".")[0] : () => true,
         )
         .map((i) =>
-          ts.factory.createImportDeclaration(
+          factory.createImportDeclaration(
             undefined,
-            ts.factory.createImportClause(
+            factory.createImportClause(
               false,
               undefined,
-              ts.factory.createNamedImports([
-                ts.factory.createImportSpecifier(
+              factory.createNamedImports([
+                factory.createImportSpecifier(
                   false,
                   undefined,
-                  ts.factory.createIdentifier(i),
+                  factory.createIdentifier(i),
                 ),
               ]),
             ),
-            ts.factory.createStringLiteral(dtoPath(i)),
+            factory.createStringLiteral(dtoPath(i)),
           ),
         ),
     ];

package/src/programmers/NestiaMigrateNestControllerProgrammer.ts

@@ -1,5 +1,5 @@
+import { type Statement, SyntaxKind, factory } from "@ttsc/factory";
 import { OpenApi } from "@typia/interface";
-import ts from "typescript";
 
 import { INestiaMigrateConfig } from "../structures/INestiaMigrateConfig";
 import { INestiaMigrateController } from "../structures/INestiaMigrateController";
@@ -15,14 +15,14 @@ export namespace NestiaMigrateNestControllerProgrammer {
     controller: INestiaMigrateController;
   }
 
-  export const write = (props: IProps): ts.Statement[] => {
+  export const write = (props: IProps): Statement[] => {
     const importer: NestiaMigrateImportProgrammer =
       new NestiaMigrateImportProgrammer();
-    const $class = ts.factory.createClassDeclaration(
+    const $class = factory.createClassDeclaration(
       [
-        ts.factory.createDecorator(
-          ts.factory.createCallExpression(
-            ts.factory.createIdentifier(
+        factory.createDecorator(
+          factory.createCallExpression(
+            factory.createIdentifier(
               importer.external({
                 type: "instance",
                 library: "@nestjs/common",
@@ -30,10 +30,10 @@ export namespace NestiaMigrateNestControllerProgrammer {
               }),
             ),
             [],
-            [ts.factory.createStringLiteral(props.controller.path)],
+            [factory.createStringLiteral(props.controller.path)],
           ),
         ),
-        ts.factory.createToken(ts.SyntaxKind.ExportKeyword),
+        factory.createToken(SyntaxKind.ExportKeyword),
       ],
       props.controller.name,
       [],

package/src/programmers/NestiaMigrateNestMethodProgrammer.ts

@@ -1,13 +1,22 @@
+import {
+  type Decorator,
+  type Expression,
+  type Identifier,
+  type MethodDeclaration,
+  type ParameterDeclaration,
+  SyntaxKind,
+  type TypeNode,
+  factory,
+} from "@ttsc/factory";
+import { IHttpMigrateRoute } from "@typia/interface";
+import { OpenApi } from "typia";
+
 import {
   ExpressionFactory,
   IdentifierFactory,
   LiteralFactory,
   TypeFactory,
-} from "@typia/core";
-import { IHttpMigrateRoute } from "@typia/interface";
-import ts from "typescript";
-import { OpenApi } from "typia";
-
+} from "../factories";
 import { INestiaMigrateConfig } from "../structures/INestiaMigrateConfig";
 import { INestiaMigrateController } from "../structures/INestiaMigrateController";
 import { FilePrinter } from "../utils/FilePrinter";
@@ -24,8 +33,8 @@ export namespace NestiaMigrateNestMethodProgrammer {
     route: IHttpMigrateRoute;
   }
 
-  export const write = (ctx: IContext): ts.MethodDeclaration => {
-    const output: ts.TypeNode = ctx.route.success
+  export const write = (ctx: IContext): MethodDeclaration => {
+    const output: TypeNode = ctx.route.success
       ? NestiaMigrateSchemaProgrammer.write({
           components: ctx.components,
           importer: ctx.importer,
@@ -33,19 +42,19 @@ export namespace NestiaMigrateNestMethodProgrammer {
         })
       : TypeFactory.keyword("void");
 
-    const method: ts.MethodDeclaration = ts.factory.createMethodDeclaration(
+    const method: MethodDeclaration = factory.createMethodDeclaration(
       [
         ...writeMethodDecorators(ctx),
-        ts.factory.createToken(ts.SyntaxKind.PublicKeyword),
-        ts.factory.createToken(ts.SyntaxKind.AsyncKeyword),
+        factory.createToken(SyntaxKind.PublicKeyword),
+        factory.createToken(SyntaxKind.AsyncKeyword),
       ],
       undefined,
       ctx.route.accessor.at(-1)!,
       undefined,
       undefined,
       writeParameters(ctx),
-      ts.factory.createTypeReferenceNode("Promise", [output]),
-      ts.factory.createBlock(
+      factory.createTypeReferenceNode("Promise", [output]),
+      factory.createBlock(
         [
           ...[
             ...ctx.route.parameters.map((p) => p.key),
@@ -53,14 +62,12 @@ export namespace NestiaMigrateNestMethodProgrammer {
             ...(ctx.route.query ? ["query"] : []),
             ...(ctx.route.body ? ["body"] : []),
           ].map((str) =>
-            ts.factory.createExpressionStatement(
-              ts.factory.createIdentifier(str),
-            ),
+            factory.createExpressionStatement(factory.createIdentifier(str)),
           ),
-          ts.factory.createReturnStatement(
-            ts.factory.createCallExpression(
+          factory.createReturnStatement(
+            factory.createCallExpression(
               IdentifierFactory.access(
-                ts.factory.createIdentifier(
+                factory.createIdentifier(
                   ctx.importer.external({
                     type: "default",
                     library: "typia",
@@ -92,9 +99,9 @@ export namespace NestiaMigrateNestMethodProgrammer {
       `@${config.author?.tag ?? "nestia"} ${config.author?.value ?? "Generated by Nestia - https://github.com/samchon/nestia"}`,
     ].join("\n");
 
-  const writeMethodDecorators = (ctx: IContext): ts.Decorator[] => {
-    const external = (lib: string, instance: string): ts.Identifier =>
-      ts.factory.createIdentifier(
+  const writeMethodDecorators = (ctx: IContext): Decorator[] => {
+    const external = (lib: string, instance: string): Identifier =>
+      factory.createIdentifier(
         ctx.importer.external({
           type: "instance",
           library: lib,
@@ -103,7 +110,7 @@ export namespace NestiaMigrateNestMethodProgrammer {
       );
 
     // EXAMPLES
-    const decorators: ts.Decorator[] = [];
+    const decorators: Decorator[] = [];
     if (ctx.route.success)
       decorators.push(
         ...writeExampleDecorators("Response")(ctx.importer)(
@@ -114,8 +121,8 @@ export namespace NestiaMigrateNestMethodProgrammer {
     // HUMAN-ONLY
     if (ctx.route.operation()["x-samchon-human"] === true)
       decorators.push(
-        ts.factory.createDecorator(
-          ts.factory.createCallExpression(
+        factory.createDecorator(
+          factory.createCallExpression(
             external("@nestia/core", "HumanRoute"),
             undefined,
             undefined,
@@ -130,15 +137,15 @@ export namespace NestiaMigrateNestMethodProgrammer {
       .filter((str) => !!str.length)
       .join("/");
     const router = (instance: string) =>
-      ts.factory.createDecorator(
-        ts.factory.createCallExpression(
+      factory.createDecorator(
+        factory.createCallExpression(
           IdentifierFactory.access(
             external("@nestia/core", instance),
             StringUtil.capitalize(ctx.route.method),
           ),
           [],
           localPath.length
-            ? [ts.factory.createStringLiteral(localPath)]
+            ? [factory.createStringLiteral(localPath)]
             : undefined,
         ),
       );
@@ -146,11 +153,11 @@ export namespace NestiaMigrateNestMethodProgrammer {
       decorators.push(router("EncryptedRoute"));
     else if (ctx.route.success?.type === "text/plain")
       decorators.push(
-        ts.factory.createDecorator(
-          ts.factory.createCallExpression(
+        factory.createDecorator(
+          factory.createCallExpression(
             external("@nestjs/common", StringUtil.capitalize(ctx.route.method)),
             [],
-            [ts.factory.createStringLiteral(ctx.route.path)],
+            [factory.createStringLiteral(ctx.route.path)],
           ),
         ),
       );
@@ -158,11 +165,11 @@ export namespace NestiaMigrateNestMethodProgrammer {
       decorators.push(router("TypedQuery"));
     else if (ctx.route.method === "head")
       decorators.push(
-        ts.factory.createDecorator(
-          ts.factory.createCallExpression(
+        factory.createDecorator(
+          factory.createCallExpression(
             external("@nestjs/common", "Head"),
             [],
-            [ts.factory.createStringLiteral(ctx.route.path)],
+            [factory.createStringLiteral(ctx.route.path)],
           ),
         ),
       );
@@ -173,8 +180,8 @@ export namespace NestiaMigrateNestMethodProgrammer {
       decorators.push(router("TypedRoute"));
     for (const [key, value] of Object.entries(ctx.route.exceptions ?? {}))
       decorators.push(
-        ts.factory.createDecorator(
-          ts.factory.createCallExpression(
+        factory.createDecorator(
+          factory.createCallExpression(
             external("@nestia/core", "TypedException"),
             [
               NestiaMigrateSchemaProgrammer.write({
@@ -185,14 +192,10 @@ export namespace NestiaMigrateNestMethodProgrammer {
             ],
             [
               isNaN(Number(key))
-                ? ts.factory.createStringLiteral(key)
+                ? factory.createStringLiteral(key)
                 : ExpressionFactory.number(Number(key)),
               ...(value.response().description?.length
-                ? [
-                    ts.factory.createStringLiteral(
-                      value.response().description!,
-                    ),
-                  ]
+                ? [factory.createStringLiteral(value.response().description!)]
                 : []),
             ],
           ),
@@ -201,14 +204,14 @@ export namespace NestiaMigrateNestMethodProgrammer {
     return decorators;
   };
 
-  const writeParameters = (ctx: IContext): ts.ParameterDeclaration[] => [
+  const writeParameters = (ctx: IContext): ParameterDeclaration[] => [
     ...ctx.route.parameters.map((p) =>
-      ts.factory.createParameterDeclaration(
+      factory.createParameterDeclaration(
         [
           ...writeExampleDecorators("Parameter")(ctx.importer)(p.parameter()),
-          ts.factory.createDecorator(
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier(
+          factory.createDecorator(
+            factory.createCallExpression(
+              factory.createIdentifier(
                 ctx.importer.external({
                   type: "instance",
                   library: "@nestia/core",
@@ -216,7 +219,7 @@ export namespace NestiaMigrateNestMethodProgrammer {
                 }),
               ),
               undefined,
-              [ts.factory.createStringLiteral(p.key)],
+              [factory.createStringLiteral(p.key)],
             ),
           ),
         ],
@@ -276,14 +279,14 @@ export namespace NestiaMigrateNestMethodProgrammer {
             arguments:
               ctx.route.body.type === "multipart/form-data"
                 ? [
-                    ts.factory.createArrowFunction(
+                    factory.createArrowFunction(
                       undefined,
                       undefined,
                       [],
                       undefined,
                       undefined,
-                      ts.factory.createCallExpression(
-                        ts.factory.createIdentifier(
+                      factory.createCallExpression(
+                        factory.createIdentifier(
                           ctx.importer.external({
                             type: "default",
                             library: "multer",
@@ -314,7 +317,7 @@ export namespace NestiaMigrateNestMethodProgrammer {
     (accessor: {
       method: string | [string, string];
       variable: string;
-      arguments: ts.Expression[];
+      arguments: Expression[];
     }) =>
     (components: OpenApi.IComponents) =>
     (importer: NestiaMigrateImportProgrammer) =>
@@ -323,8 +326,8 @@ export namespace NestiaMigrateNestMethodProgrammer {
       required: boolean;
       example?: any;
       examples?: Record<string, any>;
-    }): ts.ParameterDeclaration => {
-      const instance = ts.factory.createIdentifier(
+    }): ParameterDeclaration => {
+      const instance = factory.createIdentifier(
         importer.external({
           type: "instance",
           library: "@nestia/core",
@@ -334,11 +337,11 @@ export namespace NestiaMigrateNestMethodProgrammer {
               : accessor.method[0],
         }),
       );
-      return ts.factory.createParameterDeclaration(
+      return factory.createParameterDeclaration(
         [
           ...writeExampleDecorators("Parameter")(importer)(props),
-          ts.factory.createDecorator(
-            ts.factory.createCallExpression(
+          factory.createDecorator(
+            factory.createCallExpression(
               typeof accessor.method === "string"
                 ? instance
                 : IdentifierFactory.access(instance, accessor.method[1]),
@@ -350,7 +353,7 @@ export namespace NestiaMigrateNestMethodProgrammer {
         undefined,
         accessor.variable,
         props.required === false
-          ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
+          ? factory.createToken(SyntaxKind.QuestionToken)
           : undefined,
         NestiaMigrateSchemaProgrammer.write({
           components,
@@ -363,16 +366,13 @@ export namespace NestiaMigrateNestMethodProgrammer {
   const writeExampleDecorators =
     (kind: "Response" | "Parameter") =>
     (importer: NestiaMigrateImportProgrammer) =>
-    (media: {
-      example?: any;
-      examples?: Record<string, any>;
-    }): ts.Decorator[] => [
+    (media: { example?: any; examples?: Record<string, any> }): Decorator[] => [
       ...(media.example !== undefined
         ? [
-            ts.factory.createDecorator(
-              ts.factory.createCallExpression(
+            factory.createDecorator(
+              factory.createCallExpression(
                 IdentifierFactory.access(
-                  ts.factory.createIdentifier(
+                  factory.createIdentifier(
                     importer.external({
                       type: "instance",
                       library: "@nestia/core",
@@ -388,10 +388,10 @@ export namespace NestiaMigrateNestMethodProgrammer {
           ]
         : []),
       ...Object.entries(media.examples ?? {}).map(([key, value]) =>
-        ts.factory.createDecorator(
-          ts.factory.createCallExpression(
+        factory.createDecorator(
+          factory.createCallExpression(
             IdentifierFactory.access(
-              ts.factory.createIdentifier(
+              factory.createIdentifier(
                 importer.external({
                   type: "instance",
                   library: "@nestia/core",
@@ -401,7 +401,7 @@ export namespace NestiaMigrateNestMethodProgrammer {
               kind,
             ),
             [],
-            [ts.factory.createStringLiteral(key), LiteralFactory.write(value)],
+            [factory.createStringLiteral(key), LiteralFactory.write(value)],
           ),
         ),
       ),