Add post history tracking and restructure timestamps

packages/backend_app/openapi.json

@@ -54,18 +54,17 @@
           "created_at": {
             "type": "string",
             "format": "date-time",
-            "description": "The date and time the post was created",
+            "description": "The date and time the post was originally created",
             "example": "2025-01-01T00:00:00Z"
           },
           "updated_at": {
             "type": "string",
             "format": "date-time",
-            "description": "The date and time the post was updated",
+            "description": "The date and time the post was created (or last updated in case of delete&insert)",
             "example": "2025-01-01T00:00:00Z"
           }
         },
-        "required": ["public_id", "content", "created_at", "updated_at"],
-        "additionalProperties": false
+        "required": ["public_id", "content", "created_at", "updated_at"]
       }
     },
     "parameters": {}
@@ -399,8 +398,7 @@
                             "properties": {
                               "user": { "$ref": "#/components/schemas/user" }
                             },
-                            "required": ["user"],
-                            "additionalProperties": false
+                            "required": ["user"]
                           }
                         ]
                       }
@@ -582,8 +580,7 @@
                           "properties": {
                             "user": { "$ref": "#/components/schemas/user" }
                           },
-                          "required": ["user"],
-                          "additionalProperties": false
+                          "required": ["user"]
                         }
                       ]
                     }
@@ -752,7 +749,8 @@
                     "description": "The content of the post",
                     "example": "test"
                   }
-                }
+                },
+                "required": ["content"]
               }
             }
           }
@@ -773,8 +771,7 @@
                           "properties": {
                             "user": { "$ref": "#/components/schemas/user" }
                           },
-                          "required": ["user"],
-                          "additionalProperties": false
+                          "required": ["user"]
                         }
                       ]
                     }

packages/backend_app/src/apps/posts/dto.ts

@@ -1,47 +1,69 @@
 import { z } from "@hono/zod-openapi";
-import { postPublicFields } from "../../db/field";
 import { postsTable } from "../../db/schema";
-import {
-  createInsertSchema,
-  createSelectSchema,
-  createUpdateSchema,
-} from "../factory";
+import { createInsertSchema, createUpdateSchema } from "../factory";
 import { userSelectSchema } from "../user/dto";
 
-const postSelectSchema = createSelectSchema(postsTable, {
-  public_id: (schema) =>
-    schema.openapi({
+export const postSchema = z
+  .object({
+    public_id: z.uuid().openapi({
       description: "Public ID",
       example: "123e4567-e89b-12d3-a456-426614174000",
     }),
-  content: (schema) =>
-    schema.openapi({
+    content: z.string().openapi({
       description: "The content of the post",
       example: "test",
     }),
-  created_at: (schema) =>
-    schema.openapi({
-      description: "The date and time the post was created",
+    created_at: z.iso.datetime().openapi({
+      description: "The date and time the post was originally created",
       example: "2025-01-01T00:00:00Z",
       format: "date-time",
     }),
-  updated_at: (schema) =>
-    schema.openapi({
-      description: "The date and time the post was updated",
+    updated_at: z.iso.datetime().openapi({
+      description:
+        "The date and time the post was created (or last updated in case of delete&insert)",
       example: "2025-01-01T00:00:00Z",
       format: "date-time",
     }),
-})
-  .pick(postPublicFields)
-  .strict()
+  })
   .openapi("post");
 
-export const postWithUserSelectSchema = postSelectSchema.extend({
-  user: userSelectSchema,
+// DB データから API レスポンス形式への変換関数
+export const transformPost = (post: {
+  public_id: string;
+  content: string;
+  first_created_at: Date;
+  created_at: Date;
+}): z.infer<typeof postSchema> => ({
+  public_id: post.public_id,
+  content: post.content,
+  created_at: post.first_created_at.toISOString(), // first_created_at → created_at
+  updated_at: post.created_at.toISOString(), // created_at → updated_at
 });
 
+// user 付きの変換関数
+export const transformPostWithUser = <
+  T extends {
+    public_id: string;
+    content: string;
+    first_created_at: Date;
+    created_at: Date;
+    user: z.infer<typeof userSelectSchema>;
+  },
+>(
+  post: T,
+): z.infer<typeof postWithUserResponseSchema> => ({
+  ...transformPost(post),
+  user: post.user,
+});
+
+export const postWithUserResponseSchema = postSchema.and(
+  z.object({
+    user: userSelectSchema,
+  }),
+);
+
 export const getPostsResponseSchema = z.object({
-  posts: postWithUserSelectSchema.array(),
+  posts: postWithUserResponseSchema.array(),
 });
 
 export const postPostRequestSchema = createInsertSchema(postsTable, {
@@ -55,7 +77,7 @@ export const postPostRequestSchema = createInsertSchema(postsTable, {
 });
 
 export const postPostResponseSchema = z.object({
-  post: postWithUserSelectSchema,
+  post: postWithUserResponseSchema,
 });
 
 export const updatePostParamsSchema = z.object({
@@ -68,9 +90,11 @@ export const updatePostRequestSchema = createUpdateSchema(postsTable, {
       description: "The content of the post",
       example: "test",
     }),
-}).pick({
-  content: true,
-});
+})
+  .pick({
+    content: true,
+  })
+  .required();
 
 export const updatePostResponseSchema = postPostResponseSchema;
 

packages/backend_app/src/apps/posts/index.test.ts

@@ -4,7 +4,7 @@ import type { ClientRequestOptions } from "hono/client";
 import { testClient } from "hono/testing";
 import { app } from "../../apps";
 import { db } from "../../db";
-import { postsTable, usersTable } from "../../db/schema";
+import { postLogsTable, postsTable, usersTable } from "../../db/schema";
 import { supabaseUid } from "../../test/supabase";
 
 describe("postsApp", () => {
@@ -21,6 +21,7 @@ describe("postsApp", () => {
       await db
         .insert(usersTable)
         .values({
+          public_id: faker.string.uuid(),
           supabase_uid: supabaseUid,
           display_name: faker.person.fullName(),
         })
@@ -33,6 +34,7 @@ describe("postsApp", () => {
       await db
         .insert(usersTable)
         .values({
+          public_id: faker.string.uuid(),
           supabase_uid: faker.string.uuid(),
           display_name: faker.person.fullName(),
         })
@@ -58,12 +60,19 @@ describe("postsApp", () => {
 
     describe("when there are some posts", () => {
       beforeEach(async () => {
-        await db
-          .insert(postsTable)
-          .values({ user_id: user.id, content: "test" });
-        await db
-          .insert(postsTable)
-          .values({ user_id: user.id, content: "test2" });
+        const now = new Date();
+        await db.insert(postsTable).values({
+          public_id: faker.string.uuid(),
+          user_id: user.id,
+          content: "test",
+          first_created_at: now,
+        });
+        await db.insert(postsTable).values({
+          public_id: faker.string.uuid(),
+          user_id: user.id,
+          content: "test2",
+          first_created_at: now,
+        });
       });
 
       it("should return 200 Response", async () => {
@@ -76,8 +85,8 @@ describe("postsApp", () => {
         expect(json.posts[0]).toEqual({
           public_id: expect.any(String),
           content: "test2",
-          created_at: expect.any(String),
-          updated_at: expect.any(String),
+          created_at: expect.any(String), // first_created_at → created_at に変換
+          updated_at: expect.any(String), // created_at → updated_at に変換
           user: {
             public_id: user.public_id,
             display_name: user.display_name,
@@ -86,8 +95,8 @@ describe("postsApp", () => {
         expect(json.posts[1]).toEqual({
           public_id: expect.any(String),
           content: "test",
-          created_at: expect.any(String),
-          updated_at: expect.any(String),
+          created_at: expect.any(String), // first_created_at → created_at に変換
+          updated_at: expect.any(String), // created_at → updated_at に変換
           user: {
             public_id: user.public_id,
             display_name: user.display_name,
@@ -133,7 +142,18 @@ describe("postsApp", () => {
         const post = posts[0];
         if (!post) throw new Error("post is not found");
         expect(post.content).toBe(content);
-        expect(post.created_at).toEqual(post.updated_at);
+
+        const postLogs = await db.select().from(postLogsTable);
+        expect(postLogs).toHaveLength(1);
+        const postLog = postLogs[0];
+        if (!postLog) throw new Error("postLog is not found");
+        expect(postLog.public_id).toBe(post.public_id);
+        expect(postLog.user_id).toBe(post.user_id);
+        expect(postLog.content).toBe(content);
+
+        // first_created_atが正しく設定されていることを確認
+        expect(post.first_created_at).toBeDefined();
+        expect(post.first_created_at).toBeInstanceOf(Date);
       });
     });
 
@@ -189,10 +209,21 @@ describe("postsApp", () => {
       });
 
       describe("when post is found", () => {
+        let firstPost: typeof postsTable.$inferSelect;
+
         beforeEach(async () => {
-          await db
+          const result = await db
             .insert(postsTable)
-            .values({ public_id, user_id: user.id, content: "test" });
+            .values({
+              public_id,
+              user_id: user.id,
+              content: "test",
+              first_created_at: new Date(),
+            })
+            .returning();
+          const post = result[0];
+          if (!post) throw new Error("post is not found");
+          firstPost = post;
         });
 
         it("should return 200 Response", async () => {
@@ -209,17 +240,30 @@ describe("postsApp", () => {
           const post = posts[0];
           if (!post) throw new Error("post is not found");
           expect(post.content).toBe(content);
-          expect(post.created_at.getTime()).toBeLessThan(
-            post.updated_at.getTime(),
-          );
+          expect(post.public_id).toBe(public_id);
+
+          // first_created_atが維持されていることを確認
+          expect(post.first_created_at).toEqual(firstPost.first_created_at);
+
+          const postLogs = await db.select().from(postLogsTable);
+          expect(postLogs).toHaveLength(1);
+          const postLog = postLogs[0];
+          if (!postLog) throw new Error("postLog is not found");
+          expect(postLog.id).toBe(post.id);
+          expect(postLog.public_id).toBe(post.public_id);
+          expect(postLog.user_id).toBe(post.user_id);
+          expect(postLog.content).toBe(content);
         });
       });
 
       describe("when post user is not the same as the current user", () => {
         beforeEach(async () => {
-          await db
-            .insert(postsTable)
-            .values({ public_id, user_id: anotherUser.id, content: "test" });
+          await db.insert(postsTable).values({
+            public_id,
+            user_id: anotherUser.id,
+            content: "test",
+            first_created_at: new Date(),
+          });
         });
 
         it("should return 403 Response", async () => {
@@ -289,9 +333,12 @@ describe("postsApp", () => {
 
       describe("when post is found", () => {
         beforeEach(async () => {
-          await db
-            .insert(postsTable)
-            .values({ public_id, user_id: user.id, content: "test" });
+          await db.insert(postsTable).values({
+            public_id,
+            user_id: user.id,
+            content: "test",
+            first_created_at: new Date(),
+          });
         });
 
         it("should return 200 Response", async () => {
@@ -305,9 +352,12 @@ describe("postsApp", () => {
 
       describe("when post user is not the same as the current user", () => {
         beforeEach(async () => {
-          await db
-            .insert(postsTable)
-            .values({ public_id, user_id: anotherUser.id, content: "test" });
+          await db.insert(postsTable).values({
+            public_id,
+            user_id: anotherUser.id,
+            content: "test",
+            first_created_at: new Date(),
+          });
         });
 
         it("should return 403 Response", async () => {