feat: optional対応

Author: Himenon

Diff for: src/__tests__/generateInterface-test.ts

@@ -4,7 +4,7 @@ describe("Interface Generator", () => {
   it("Change Interface Name", () => {
     const name = "MyTestInterface";
     const expectResult = `interface ${name} {\n}\n`;
-    const result = generateInterface({ name, schemas: {} });
+    const result = generateInterface({ name, schema: {} });
     expect(result).toBe(expectResult);
   });
 });

Diff for: src/__tests__/interfaceMembers-test.ts

@@ -8,26 +8,18 @@ const schemas: JSONSchema4 = {
       type: "string",
       required: false,
     },
-    age: {
-      type: "number",
-    },
-    body: {
-      type: "object",
-      properties: {
-        child: {
-          type: "string",
-        },
-      },
-    },
   },
 };
 
+const interfaceName = "MyTestInterface";
+const expectResult = `interface ${interfaceName} {
+    name?: string;
+}
+`;
+
 describe("Interface Generator", () => {
   it("Change Interface Name", () => {
-    const name = "MyTestInterface";
-    const expectResult = `interface ${name} {\n}\n`;
-    const result = generateInterface({ name, schemas });
-    console.log(JSON.stringify(result));
+    const result = generateInterface({ name: interfaceName, schema: schemas });
     expect(result).toBe(expectResult);
   });
 });

Diff for: src/generateInterface.ts

@@ -4,22 +4,17 @@ import { JSONSchema4 } from "json-schema";
 
 interface Params {
   name: string;
-  schemas: JSONSchema4;
+  schema?: JSONSchema4;
 }
 
-const code = `
-interface DummyInterface {
-
-}
-`;
+const code = `interface DummyInterface {}`;
 
 export const generateInterface = (params: Params): string => {
   const result = transform(code, [
     Traverse.InterfaceName.traverse({ name: params.name }),
     Traverse.InterfaceAppendMembers.traverse({
-      schemas: params.schemas,
+      schemas: params.schema || {},
     }),
   ]);
-  console.log({ result });
   return result;
 };

Diff for: src/traverse/interfaceAppendMembers.ts

@@ -33,6 +33,22 @@ const createObjectMemberType = ({ factory }: ts.TransformationContext, members:
   return factory.createTypeLiteralNode(members);
 };
 
+const createOptional = ({ factory }: ts.TransformationContext) => {
+  return factory.createToken(ts.SyntaxKind.QuestionToken);
+};
+
+const createPropertySignatures = (context: ts.TransformationContext, properties: { [key: string]: JSONSchema4 }): ts.PropertySignature[] => {
+  return Object.entries(properties).map(([key, childSchema]) => {
+    childSchema.required;
+    return context.factory.createPropertySignature(
+      undefined,
+      context.factory.createIdentifier(key),
+      childSchema.required === false ? createOptional(context) : undefined,
+      createTypeNode(context, childSchema),
+    );
+  });
+};
+
 /**
  * Don't use root schema root
  */
@@ -41,14 +57,7 @@ const createTypeNode = (context: ts.TransformationContext, schema: JSONSchema4):
     if (!schema.properties) {
       return createObjectMemberType(context, []);
     }
-    const members = Object.entries(schema.properties).map(([key, childSchema]) => {
-      return context.factory.createPropertySignature(
-        undefined,
-        context.factory.createIdentifier(key),
-        undefined,
-        createTypeNode(context, childSchema),
-      );
-    });
+    const members = createPropertySignatures(context, schema.properties);
     return createObjectMemberType(context, members);
   } else if (schema.type === "string") {
     return createStringType(context);
@@ -78,14 +87,7 @@ const createInterfaceFromRootObjectSchema = (context: ts.TransformationContext,
   if (schema.type !== "object" || !schema.properties) {
     return [];
   }
-  return Object.entries(schema.properties).map(([key, childSchema]) => {
-    return context.factory.createPropertySignature(
-      undefined,
-      context.factory.createIdentifier(key),
-      undefined,
-      createTypeNode(context, childSchema),
-    );
-  });
+  return createPropertySignatures(context, schema.properties);
 };
 
 /**