Zod를 이용한 Json Schema 공유 시스템 만들기

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "user": {
      "type": "object",
      "properties": {
        "id": {
          "type": "string",
          "format": "uuid"
        },
        "name": {
          "type": "string",
          "minLength": 1
        },
        "email": {
          "type": "string",
          "format": "email"
        }
      },
      "required": ["id", "name", "email"]
    },
    "payment": {
      "type": "object",
      "properties": {
        "method": {
          "type": "string",
          "enum": ["credit_card", "paypal", "bank_transfer"]
        },
        "transactionId": { "type": "string" },
        "amount": {
          "type": "number",
          "minimum": 0
        }
      },
      "required": ["method", "transactionId", "amount"]
    }
  },
  "required": ["user", "payment"]
}

z.object({
  user: z.object({
    id: z.string().uuid(),
    name: z.string().min(1),
    email: z.string().email(),
  }),
  payment: z.object({
    method: z.enum(["credit_card", "paypal", "bank_transfer"]),
    transactionId: z.string(),
    amount: z.number().min(0),
  }),
});

name: JSON Schema Generation and Validation
 
on:
  push:
    branches:
      - main
 
jobs:
  build:
    name: JSON Schema Generator
    runs-on: ubuntu-latest
 
    steps:
      # 1. Check out the repository
      - uses: actions/checkout@v2
 
      # 2. Install dependencies using Yarn
      - uses: borales/actions-yarn@v4
        with:
          cmd: install
 
      # 3. Run tests
      - uses: borales/actions-yarn@v4
        with:
          cmd: test
 
      # 4. Run the 'yarn generate' command to generate files
      - uses: borales/actions-yarn@v4
        with:
          cmd: generate
 
      # 5. Check for changes, commit, and push
      - name: Commit and Push changes if any
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          git config --global user.name "github-actions[bot]"
          git config --global user.email "github-actions[bot]@users.noreply.github.com"
          git add .
 
          # Check if there are any changes to commit
          if git diff --staged --quiet; then
            echo "No changes to commit."
          else
            git commit -m "Generated files via GitHub Actions"
 
            # Pull the latest changes from the remote before pushing
            git pull --rebase origin main
 
            # Push the changes to the main branch
            git push origin HEAD:main
          fi

│  generate-schemas.ts
│  jest.config.js
│  validation.test.ts
│
├─.github
│  └─workflows
│          main.yml
│
└─schema
    └─user
        │  index.ts
        │  readme.md
        │
        └─examples
                user-pay.json
                user-only.json

import * as fs from "fs";
import path from "path";
 
const schemaFolders = fs.readdirSync("./schema");
 
schemaFolders.forEach((schemaFolder) => {
  describe(`${schemaFolder} 스키마 테스트`, () => {
    const schemaFolderPath = path.join(__dirname, "schema", schemaFolder);
 
    const examplesFolderPath = path.join(schemaFolderPath, "examples");
    const schemaFilePath = path.join(schemaFolderPath, "index.ts");
 
    it.each(fs.readdirSync(examplesFolderPath))(
      `${schemaFolder}/%s validation`,
      async (fileName) => {
        const validator = (await import(schemaFilePath)).default;
 
        const raw = fs.readFileSync(
          path.join(examplesFolderPath, fileName),
          "utf-8"
        );
 
        const json = JSON.parse(raw);
        const parseResult = validator.safeParse(json);
 
        if (parseResult.success === false) {
          console.error(parseResult.error);
        }
        expect(parseResult.success).toEqual(true);
      }
    );
  });
});

import fs from "fs/promises";
import path from "path";
import { zodToJsonSchema } from "zod-to-json-schema";
 
const jsonSchemaFolderPath = path.join(__dirname, "jsonSchema");
 
(async () => {
  // jsonSchema 폴더가 없으면 생성
  try {
    await fs.mkdir(jsonSchemaFolderPath, { recursive: true });
  } catch (error) {
    console.error(`Error creating directory ${jsonSchemaFolderPath}:`, error);
    process.exit(1); // 오류 발생 시 종료
  }
 
  // 기존 파일 삭제
  try {
    const files = await fs.readdir(jsonSchemaFolderPath);
    for (const file of files) {
      const filePath = path.join(jsonSchemaFolderPath, file);
      await fs.unlink(filePath);
    }
  } catch (error) {
    console.error(
      `Error reading or deleting files in ${jsonSchemaFolderPath}:`,
      error
    );
  }
 
  // 스키마 폴더 읽기
  try {
    const schemaFolders = await fs.readdir("./schema");
 
    // json 스키마 파일 생성
    await Promise.all(
      schemaFolders.map(async (schemaFolder) => {
        const schemaFolderPath = path.join(__dirname, "schema", schemaFolder);
        const schemaFilePath = path.join(schemaFolderPath, "index.ts");
 
        const validator = (await import(schemaFilePath)).default;
 
        const jsonSchemaFilePath = path.join(
          jsonSchemaFolderPath,
          `${schemaFolder}.json`
        );
 
        await fs.writeFile(
          jsonSchemaFilePath,
          JSON.stringify(zodToJsonSchema(validator), null, 4)
        );
      })
    );
  } catch (error) {
    console.error("Error generating schemas:", error);
    process.exit(1); // 오류 발생 시 종료
  }
})();