@cherishxn/agent-scaffold 0.0.0-stage → 1.1.0

package/templates/react-spring-antd/backend/src/main/java/dev/scaffold/app/Api.java

@@ -0,0 +1,38 @@
+package dev.scaffold.app;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.server.ResponseStatusException;
+import org.springframework.http.HttpStatus;
+import org.springframework.security.authentication.*;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.core.AuthenticationException;
+import org.springframework.security.web.context.HttpSessionSecurityContextRepository;
+import org.springframework.security.web.authentication.logout.SecurityContextLogoutHandler;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Sort;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.core.io.ClassPathResource;
+import jakarta.servlet.http.*;
+import java.util.*;
+import java.time.Instant;
+@RestController @RequestMapping("/api")
+public class Api {
+ private final Users users;private final Records records;private final AuthenticationManager manager;
+ public Api(Users users,Records records,AuthenticationManager manager){this.users=users;this.records=records;this.manager=manager;}
+ private static ResponseStatusException invalid(){return new ResponseStatusException(HttpStatus.UNPROCESSABLE_ENTITY);}
+ private static UUID id(String value){try{return UUID.fromString(value);}catch(IllegalArgumentException e){throw invalid();}}
+ private AppUser user(Authentication auth){return users.findByEmail(auth.getName()).orElseThrow(()->new ResponseStatusException(HttpStatus.UNAUTHORIZED));}
+ private static String[] input(Map<String,Object> body){if(!body.keySet().equals(Set.of("title","content"))||!(body.get("title") instanceof String)||!(body.get("content") instanceof String))throw invalid();String title=((String)body.get("title")).strip(),content=(String)body.get("content");int n=title.codePointCount(0,title.length());if(n<1||n>120||content.codePointCount(0,content.length())>10000)throw invalid();return new String[]{title,content};}
+ private static Map<String,Object> out(PersonalRecord r){return Map.of("id",r.id.toString(),"title",r.title,"content",r.content,"created_at",r.createdAt.toString(),"updated_at",r.updatedAt.toString());}
+ private PersonalRecord owned(UUID id,UUID owner){return records.findByIdAndOwnerId(id,owner).orElseThrow(()->new ResponseStatusException(HttpStatus.NOT_FOUND));}
+ @GetMapping("/health") public Map<String,String> health(){return Map.of("status","ok");}
+ @GetMapping(value="/openapi.json",produces="application/json") public ClassPathResource openapi(){return new ClassPathResource("openapi.json");}
+ @PostMapping("/auth/login") public Map<String,Object> login(@RequestBody Map<String,Object> body,HttpServletRequest request,HttpServletResponse response){if(!body.keySet().equals(Set.of("email","password"))||!(body.get("email") instanceof String)||!(body.get("password") instanceof String))throw invalid();try{var auth=manager.authenticate(UsernamePasswordAuthenticationToken.unauthenticated(((String)body.get("email")).strip().toLowerCase(Locale.ROOT),body.get("password")));var context=SecurityContextHolder.createEmptyContext();context.setAuthentication(auth);request.getSession(true);request.changeSessionId();SecurityContextHolder.setContext(context);new HttpSessionSecurityContextRepository().saveContext(context,request,response);var u=user(auth);return Map.of("user",Map.of("id",u.id.toString(),"email",u.email),"mode","session");}catch(AuthenticationException e){throw new ResponseStatusException(HttpStatus.UNAUTHORIZED);}}
+ @GetMapping("/auth/me") public Map<String,Object> me(Authentication auth){var u=user(auth);return Map.of("user",Map.of("id",u.id.toString(),"email",u.email));}
+ @PostMapping("/auth/logout") @ResponseStatus(HttpStatus.NO_CONTENT) public void logout(HttpServletRequest req,HttpServletResponse res,Authentication auth){new SecurityContextLogoutHandler().logout(req,res,auth);}
+ @GetMapping("/records") public Map<String,Object> list(Authentication auth,@RequestParam(defaultValue="1") int page,@RequestParam(defaultValue="10") int pageSize){if(page<1||page>1000000||pageSize<1||pageSize>100)throw invalid();var rows=records.findByOwnerId(user(auth).id,PageRequest.of(page-1,pageSize,Sort.by(Sort.Direction.DESC,"createdAt","id")));return Map.of("items",rows.getContent().stream().map(Api::out).toList(),"total",rows.getTotalElements(),"page",page,"pageSize",pageSize);}
+ @PostMapping("/records") @ResponseStatus(HttpStatus.CREATED) public Map<String,Object> create(Authentication auth,@RequestBody Map<String,Object> body){var data=input(body);return out(records.saveAndFlush(new PersonalRecord(user(auth).id,data[0],data[1])));}
+ @GetMapping("/records/{recordId}") public Map<String,Object> detail(Authentication auth,@PathVariable String recordId){return out(owned(id(recordId),user(auth).id));}
+ @PutMapping("/records/{recordId}") @Transactional public Map<String,Object> update(Authentication auth,@PathVariable String recordId,@RequestBody Map<String,Object> body){var data=input(body);var owner=user(auth).id;var key=id(recordId);if(records.updateOwned(key,owner,data[0],data[1],Instant.now())==0)throw new ResponseStatusException(HttpStatus.NOT_FOUND);return out(owned(key,owner));}
+ @DeleteMapping("/records/{recordId}") @Transactional @ResponseStatus(HttpStatus.NO_CONTENT) public void delete(Authentication auth,@PathVariable String recordId){if(records.deleteOwned(id(recordId),user(auth).id)==0)throw new ResponseStatusException(HttpStatus.NOT_FOUND);}
+}

package/templates/react-spring-antd/backend/src/main/java/dev/scaffold/app/AppUser.java

@@ -0,0 +1,11 @@
+package dev.scaffold.app;
+import jakarta.persistence.*;
+import java.util.UUID;
+@Entity @Table(name="app_user")
+public class AppUser {
+ @Id UUID id=UUID.randomUUID();
+ @Column(nullable=false,unique=true,length=320) String email;
+ @Column(nullable=false) String password;
+ protected AppUser(){}
+ AppUser(String email,String password){this.email=email;this.password=password;}
+}

package/templates/react-spring-antd/backend/src/main/java/dev/scaffold/app/Application.java

@@ -0,0 +1,7 @@
+package dev.scaffold.app;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+@SpringBootApplication
+public class Application {
+ public static void main(String[] args) { var context=SpringApplication.run(Application.class,args);if(context.getEnvironment().getProperty("scaffold.migrate-only",Boolean.class,false)||context.getEnvironment().getProperty("scaffold.seed-only",Boolean.class,false)){SpringApplication.exit(context);}}
+}

package/templates/react-spring-antd/backend/src/main/java/dev/scaffold/app/Errors.java

@@ -0,0 +1,13 @@
+package dev.scaffold.app;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.server.ResponseStatusException;
+import org.springframework.http.ResponseEntity;
+import org.springframework.http.converter.HttpMessageNotReadableException;
+import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
+import java.util.Map;
+@RestControllerAdvice
+public class Errors {
+ @ExceptionHandler(ResponseStatusException.class) ResponseEntity<?> status(ResponseStatusException e){return error(e.getStatusCode().value());}
+ @ExceptionHandler({HttpMessageNotReadableException.class,MethodArgumentTypeMismatchException.class}) ResponseEntity<?> invalid(Exception e){return error(422);}
+ private ResponseEntity<?> error(int status){String message=switch(status){case 401->"请重新登录。";case 404->"记录不存在。";case 422->"输入不合法，请检查字段和长度。";default->"请求失败。";};return ResponseEntity.status(status).body(Map.of("error",Map.of("code",String.valueOf(status),"message",message)));}
+}

package/templates/react-spring-antd/backend/src/main/java/dev/scaffold/app/PersonalRecord.java

@@ -0,0 +1,15 @@
+package dev.scaffold.app;
+import jakarta.persistence.*;
+import java.time.Instant;
+import java.util.UUID;
+@Entity @Table(name="personal_record")
+public class PersonalRecord {
+ @Id UUID id=UUID.randomUUID();
+ @Column(name="owner_id",nullable=false) UUID ownerId;
+ @Column(nullable=false,length=120) String title;
+ @Column(nullable=false,columnDefinition="text") String content;
+ @Column(name="created_at",nullable=false) Instant createdAt=Instant.now();
+ @Column(name="updated_at",nullable=false) Instant updatedAt=Instant.now();
+ protected PersonalRecord(){}
+ PersonalRecord(UUID ownerId,String title,String content){this.ownerId=ownerId;this.title=title;this.content=content;}
+}

package/templates/react-spring-antd/backend/src/main/java/dev/scaffold/app/Records.java

@@ -0,0 +1,14 @@
+package dev.scaffold.app;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import java.util.Optional;
+import java.util.UUID;
+public interface Records extends JpaRepository<PersonalRecord,UUID>{
+ Page<PersonalRecord> findByOwnerId(UUID ownerId,Pageable page);
+ Optional<PersonalRecord> findByIdAndOwnerId(UUID id,UUID ownerId);
+ @Modifying @Query("delete from PersonalRecord r where r.id=:id and r.ownerId=:ownerId") int deleteOwned(UUID id,UUID ownerId);
+ @Modifying @Query("update PersonalRecord r set r.title=:title,r.content=:content,r.updatedAt=:now where r.id=:id and r.ownerId=:ownerId") int updateOwned(UUID id,UUID ownerId,String title,String content,java.time.Instant now);
+}

package/templates/react-spring-antd/backend/src/main/java/dev/scaffold/app/Security.java

@@ -0,0 +1,28 @@
+package dev.scaffold.app;
+import org.springframework.context.annotation.*;
+import org.springframework.security.authentication.*;
+import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.http.SessionCreationPolicy;
+import org.springframework.security.core.userdetails.*;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.security.web.SecurityFilterChain;
+import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
+import org.springframework.web.filter.OncePerRequestFilter;
+import jakarta.servlet.*;
+import jakarta.servlet.http.*;
+import java.io.IOException;
+import java.util.Set;
+@Configuration
+public class Security {
+ @Bean PasswordEncoder encoder(){return new BCryptPasswordEncoder();}
+ @Bean UserDetailsService userDetails(Users users){return email->users.findByEmail(email).map(u->User.withUsername(u.email).password(u.password).roles("USER").build()).orElseThrow(()->new UsernameNotFoundException("Unknown account"));}
+ @Bean AuthenticationManager authenticationManager(UserDetailsService service,PasswordEncoder encoder){var provider=new DaoAuthenticationProvider(service);provider.setPasswordEncoder(encoder);return new ProviderManager(provider);}
+ @Bean SecurityFilterChain filter(HttpSecurity http) throws Exception {
+  String origin=System.getenv("APP_ORIGIN");if(origin==null)throw new IllegalStateException("APP_ORIGIN is required");
+  var originCheck=new OncePerRequestFilter(){protected void doFilterInternal(HttpServletRequest request,HttpServletResponse response,FilterChain chain)throws ServletException,IOException{if(!Set.of("GET","HEAD","OPTIONS").contains(request.getMethod())&&!origin.equals(request.getHeader("Origin"))){response.setStatus(403);response.setContentType("application/json");response.getWriter().write("{\"error\":{\"code\":\"403\",\"message\":\"Invalid request origin\"}}");return;}chain.doFilter(request,response);}};
+  http.csrf(csrf->csrf.disable()).addFilterBefore(originCheck,UsernamePasswordAuthenticationFilter.class).sessionManagement(s->s.sessionCreationPolicy(SessionCreationPolicy.IF_REQUIRED)).authorizeHttpRequests(a->a.requestMatchers("/api/health","/api/auth/login","/api/openapi.json","/error").permitAll().anyRequest().authenticated()).exceptionHandling(e->e.authenticationEntryPoint((req,res,ex)->{res.setStatus(401);res.setContentType("application/json");res.getWriter().write("{\"error\":{\"code\":\"401\",\"message\":\"Please sign in\"}}");}));
+  return http.build();
+ }
+}

package/templates/react-spring-antd/backend/src/main/java/dev/scaffold/app/Seed.java

@@ -0,0 +1,13 @@
+package dev.scaffold.app;
+import org.springframework.boot.ApplicationRunner;
+import org.springframework.boot.ApplicationArguments;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.stereotype.Component;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import java.util.Locale;
+@Component @ConditionalOnProperty(name="scaffold.seed-only",havingValue="true")
+public class Seed implements ApplicationRunner {
+ private final Users users;private final PasswordEncoder encoder;
+ public Seed(Users users,PasswordEncoder encoder){this.users=users;this.encoder=encoder;}
+ public void run(ApplicationArguments args){var password=System.getenv("SEED_PASSWORD");if(password==null||password.length()<12)throw new IllegalStateException("Provide an explicit seed password with 12+ characters");for(String key:new String[]{"SEED_A_EMAIL","SEED_B_EMAIL"}){var raw=System.getenv(key);if(raw==null)throw new IllegalStateException("Missing "+key);var email=raw.strip().toLowerCase(Locale.ROOT);if(users.findByEmail(email).isEmpty())users.saveAndFlush(new AppUser(email,encoder.encode(password)));}}
+}

package/templates/react-spring-antd/backend/src/main/java/dev/scaffold/app/Users.java

@@ -0,0 +1,5 @@
+package dev.scaffold.app;
+import org.springframework.data.jpa.repository.JpaRepository;
+import java.util.Optional;
+import java.util.UUID;
+public interface Users extends JpaRepository<AppUser,UUID>{Optional<AppUser> findByEmail(String email);}

package/templates/react-spring-antd/backend/src/main/resources/application.properties

@@ -0,0 +1,17 @@
+server.port=${PORT:8000}
+server.address=127.0.0.1
+server.servlet.session.timeout=15m
+server.servlet.session.cookie.http-only=true
+server.servlet.session.cookie.same-site=lax
+server.servlet.session.cookie.secure=${SESSION_COOKIE_SECURE:true}
+spring.datasource.url=${SPRING_DATASOURCE_URL}
+spring.datasource.username=${SPRING_DATASOURCE_USERNAME}
+spring.datasource.password=${SPRING_DATASOURCE_PASSWORD}
+spring.jpa.hibernate.ddl-auto=validate
+spring.jpa.open-in-view=false
+spring.jpa.show-sql=false
+spring.jackson.deserialization.fail-on-unknown-properties=true
+server.error.include-message=never
+server.error.include-stacktrace=never
+logging.level.root=WARN
+spring.main.banner-mode=off

package/templates/react-spring-antd/backend/src/main/resources/db/migration/V1__initial.sql

@@ -0,0 +1,3 @@
+CREATE TABLE app_user (id UUID PRIMARY KEY, email VARCHAR(320) NOT NULL UNIQUE, password VARCHAR(255) NOT NULL);
+CREATE TABLE personal_record (id UUID PRIMARY KEY, owner_id UUID NOT NULL REFERENCES app_user(id), title VARCHAR(120) NOT NULL, content TEXT NOT NULL, created_at TIMESTAMP WITH TIME ZONE NOT NULL, updated_at TIMESTAMP WITH TIME ZONE NOT NULL);
+CREATE INDEX personal_record_owner_idx ON personal_record(owner_id);

package/templates/react-spring-antd/backend/src/main/resources/openapi.json

@@ -0,0 +1,461 @@
+{
+  "openapi": "3.0.3",
+  "info": {
+    "title": "Personal Records",
+    "version": "1.0.0",
+    "description": "JWT or Session according to selected template. Session writes require the configured Origin."
+  },
+  "paths": {
+    "/api/health": {
+      "get": {
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "status": {
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "status"
+                  ]
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/auth/login": {
+      "post": {
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "additionalProperties": false,
+                "required": [
+                  "email",
+                  "password"
+                ],
+                "properties": {
+                  "email": {
+                    "type": "string"
+                  },
+                  "password": {
+                    "type": "string",
+                    "writeOnly": true
+                  }
+                }
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "user": {
+                      "type": "object",
+                      "required": [
+                        "id",
+                        "email"
+                      ],
+                      "properties": {
+                        "id": {
+                          "type": "string"
+                        },
+                        "email": {
+                          "type": "string"
+                        }
+                      }
+                    },
+                    "token": {
+                      "type": "string"
+                    },
+                    "mode": {
+                      "enum": [
+                        "jwt",
+                        "session"
+                      ]
+                    }
+                  },
+                  "required": [
+                    "user",
+                    "mode"
+                  ]
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "Identity missing or expired"
+          },
+          "404": {
+            "description": "Record absent or owned by another user"
+          },
+          "422": {
+            "description": "Invalid input or protected field"
+          }
+        }
+      }
+    },
+    "/api/auth/me": {
+      "get": {
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "user": {
+                      "type": "object",
+                      "required": [
+                        "id",
+                        "email"
+                      ],
+                      "properties": {
+                        "id": {
+                          "type": "string"
+                        },
+                        "email": {
+                          "type": "string"
+                        }
+                      }
+                    }
+                  },
+                  "required": [
+                    "user"
+                  ]
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "Identity missing or expired"
+          },
+          "404": {
+            "description": "Record absent or owned by another user"
+          },
+          "422": {
+            "description": "Invalid input or protected field"
+          }
+        }
+      }
+    },
+    "/api/auth/logout": {
+      "post": {
+        "responses": {
+          "204": {
+            "description": "Logged out; JWT is cleared client-side"
+          },
+          "401": {
+            "description": "Identity missing or expired"
+          },
+          "404": {
+            "description": "Record absent or owned by another user"
+          },
+          "422": {
+            "description": "Invalid input or protected field"
+          },
+          "403": {
+            "description": "Cross-origin session write rejected"
+          }
+        }
+      }
+    },
+    "/api/records": {
+      "get": {
+        "parameters": [
+          {
+            "name": "page",
+            "in": "query",
+            "schema": {
+              "type": "integer",
+              "minimum": 1,
+              "maximum": 1000000,
+              "default": 1
+            }
+          },
+          {
+            "name": "pageSize",
+            "in": "query",
+            "schema": {
+              "type": "integer",
+              "minimum": 1,
+              "maximum": 100,
+              "default": 10
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "required": [
+                    "items",
+                    "total",
+                    "page",
+                    "pageSize"
+                  ],
+                  "properties": {
+                    "items": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/components/schemas/Record"
+                      }
+                    },
+                    "total": {
+                      "type": "integer"
+                    },
+                    "page": {
+                      "type": "integer"
+                    },
+                    "pageSize": {
+                      "type": "integer"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "Identity missing or expired"
+          },
+          "404": {
+            "description": "Record absent or owned by another user"
+          },
+          "422": {
+            "description": "Invalid input or protected field"
+          }
+        }
+      },
+      "post": {
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "additionalProperties": false,
+                "required": [
+                  "title",
+                  "content"
+                ],
+                "properties": {
+                  "title": {
+                    "type": "string",
+                    "minLength": 1,
+                    "maxLength": 120
+                  },
+                  "content": {
+                    "type": "string",
+                    "maxLength": 10000
+                  }
+                }
+              }
+            }
+          }
+        },
+        "responses": {
+          "201": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Record"
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "Identity missing or expired"
+          },
+          "404": {
+            "description": "Record absent or owned by another user"
+          },
+          "422": {
+            "description": "Invalid input or protected field"
+          },
+          "403": {
+            "description": "Cross-origin session write rejected"
+          }
+        }
+      }
+    },
+    "/api/records/{id}": {
+      "parameters": [
+        {
+          "name": "id",
+          "in": "path",
+          "required": true,
+          "schema": {
+            "type": "string",
+            "format": "uuid"
+          }
+        }
+      ],
+      "get": {
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Record"
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "Identity missing or expired"
+          },
+          "404": {
+            "description": "Record absent or owned by another user"
+          },
+          "422": {
+            "description": "Invalid input or protected field"
+          }
+        }
+      },
+      "put": {
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "additionalProperties": false,
+                "required": [
+                  "title",
+                  "content"
+                ],
+                "properties": {
+                  "title": {
+                    "type": "string",
+                    "minLength": 1,
+                    "maxLength": 120
+                  },
+                  "content": {
+                    "type": "string",
+                    "maxLength": 10000
+                  }
+                }
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Record"
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "Identity missing or expired"
+          },
+          "404": {
+            "description": "Record absent or owned by another user"
+          },
+          "422": {
+            "description": "Invalid input or protected field"
+          },
+          "403": {
+            "description": "Cross-origin session write rejected"
+          }
+        }
+      },
+      "delete": {
+        "responses": {
+          "204": {
+            "description": "Deleted"
+          },
+          "401": {
+            "description": "Identity missing or expired"
+          },
+          "404": {
+            "description": "Record absent or owned by another user"
+          },
+          "422": {
+            "description": "Invalid input or protected field"
+          },
+          "403": {
+            "description": "Cross-origin session write rejected"
+          }
+        }
+      }
+    }
+  },
+  "components": {
+    "schemas": {
+      "Record": {
+        "type": "object",
+        "required": [
+          "id",
+          "title",
+          "content",
+          "created_at",
+          "updated_at"
+        ],
+        "properties": {
+          "id": {
+            "type": "string",
+            "format": "uuid"
+          },
+          "title": {
+            "type": "string"
+          },
+          "content": {
+            "type": "string"
+          },
+          "created_at": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "updated_at": {
+            "type": "string",
+            "format": "date-time"
+          }
+        }
+      },
+      "RecordInput": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "title",
+          "content"
+        ],
+        "properties": {
+          "title": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 120
+          },
+          "content": {
+            "type": "string",
+            "maxLength": 10000
+          }
+        }
+      }
+    }
+  }
+}