WIP: Add Sub Account

src/cliUtils/addDummyDataForTest.ts

@@ -38,6 +38,7 @@ async function main() {
     for (const name of Object.keys(users) as (keyof typeof users)[]) {
         users[name].name = name
         users[name].screenName = name
+        users[name].displayScreenName = name
         users[name].encryptedPassword = "!dummy"
         if (name === "chihiro" || name === "producer") {
             users[name].canMakeInviteCode = true
@@ -64,7 +65,7 @@ async function main() {
             const token = new AccessToken()
             token.application = app
             token.user = user
-            token.token = user.screenName
+            token.token = user.displayScreenName
             return token
         })
     )
@@ -73,7 +74,7 @@ async function main() {
             const token = new AccessToken()
             token.application = app
             token.user = user
-            token.token = "revoked." + user.screenName
+            token.token = "revoked." + user.displayScreenName
             token.revokedAt = new Date(0)
             return token
         })

src/db/entities/user.ts

@@ -1,4 +1,4 @@
-import { Entity, PrimaryGeneratedColumn, Column, OneToOne, JoinColumn } from "typeorm"
+import { Entity, PrimaryGeneratedColumn, Column, OneToOne, JoinColumn, OneToMany, ManyToOne } from "typeorm"
 import { Matches, MaxLength } from "class-validator"
 import { EntityWithTimestamps } from "../../utils/timestampColumns"
 import { InviteCode } from "./inviteCode"
@@ -17,6 +17,17 @@ export class User extends EntityWithTimestamps {
     @Matches(/^[0-9A-Za-z_]{1,20}$/)
     screenName!: string
 
+    @Column({ name: "display_screen_name", nullable: false })
+    displayScreenName!: string
+
+    @ManyToOne(type => User)
+    @JoinColumn({ name: "owner_id", referencedColumnName: "id" })
+    owner!: User | null
+
+    @Column({ name: "owner_screen_name", type: "citext", nullable: true })
+    @Matches(/^[0-9A-Za-z_]{1,20}$/)
+    ownerScreenName!: string | null
+
     @Column({ name: "encrypted_password", nullable: false })
     encryptedPassword!: string
 

src/db/migrations/1576567031553-AddSubAccountColumnToUsersTable.ts

@@ -0,0 +1,80 @@
+import { MigrationInterface, QueryRunner, TableColumn, TableIndex, TableForeignKey, TableCheck } from "typeorm"
+
+export class AddSubAccountColumnToUsersTable1576567031553 implements MigrationInterface {
+    public async up(queryRunner: QueryRunner): Promise<any> {
+        await queryRunner.addColumns("users", [
+            new TableColumn({ name: "owner_id", type: "int", isNullable: true }),
+            new TableColumn({ name: "owner_screen_name", type: "citext", isNullable: true }),
+            new TableColumn({ name: "display_screen_name", type: "citext", isNullable: true }),
+        ])
+        await queryRunner.dropIndex("users", "UQ:users:screen_name")
+        await queryRunner.createIndices("users", [
+            new TableIndex({
+                name: "UQ:users:screen_name",
+                columnNames: ["screen_name"],
+                where: "owner_screen_name IS NULL",
+                isUnique: true,
+            }),
+            new TableIndex({
+                name: "UQ:users:screen_name:owner_screen_name",
+                columnNames: ["screen_name", "owner_screen_name"],
+                where: "owner_screen_name IS NOT NULL",
+                isUnique: true,
+            }),
+            new TableIndex({
+                name: "UQ:users:display_screen_name",
+                columnNames: ["display_screen_name"],
+                isUnique: true,
+            }),
+        ])
+        await queryRunner.query("UPDATE users SET display_screen_name = screen_name")
+        await queryRunner.query("ALTER TABLE users ALTER COLUMN display_screen_name SET NOT NULL")
+        await queryRunner.createCheckConstraint(
+            "users",
+            new TableCheck({
+                name: "CHK:users:display_screen_name",
+                columnNames: ["display_screen_name"],
+                expression: "display_screen_name = COALESCE(screen_name || '.' || owner_screen_name, screen_name)",
+            })
+        )
+        await queryRunner.createForeignKeys("users", [
+            new TableForeignKey({
+                name: "FK:users:owner_id::users:id",
+                columnNames: ["owner_id"],
+                referencedTableName: "users",
+                referencedColumnNames: ["id"],
+                onDelete: "RESTRICT",
+                onUpdate: "CASCADE",
+            }),
+            new TableForeignKey({
+                name: "FK:users:owner_screen_name::users:screen_name",
+                columnNames: ["owner_screen_name"],
+                referencedTableName: "users",
+                referencedColumnNames: ["display_screen_name"],
+                onDelete: "RESTRICT",
+                onUpdate: "CASCADE",
+            }),
+        ])
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<any> {
+        await queryRunner.dropForeignKey("users", "FK:users:owner_id::users:id")
+        await queryRunner.dropForeignKey("users", "FK:users:owner_screen_name::users:screen_name")
+        await queryRunner.dropIndex("users", "UQ:users:screen_name")
+        await queryRunner.dropIndex("users", "UQ:users:screen_name:owner_screen_name")
+        await queryRunner.dropIndex("users", "UQ:users:display_screen_name")
+        await queryRunner.dropCheckConstraint("users", "CHK:users:display_screen_name")
+        await queryRunner.dropColumn("users", "owner_id")
+        await queryRunner.dropColumn("users", "owner_screen_name")
+        await queryRunner.dropColumn("users", "screen_name")
+        await queryRunner.renameColumn("users", "display_screen_name", "screen_name")
+        await queryRunner.createIndex(
+            "users",
+            new TableIndex({
+                name: "UQ:users:screen_name",
+                columnNames: ["screen_name"],
+                isUnique: true,
+            })
+        )
+    }
+}

src/db/repositories/user.ts

@@ -16,7 +16,7 @@ export class UserRepository extends Repository<User> {
             return {
                 id: user.id,
                 name: user.name,
-                screenName: user.screenName,
+                screenName: user.displayScreenName,
                 postsCount: user.postsCount,
                 createdAt: user.createdAt,
                 updatedAt: user.updatedAt,

src/routers/api/v1/posts.ts

@@ -111,14 +111,14 @@ router.post("/", koaBody(), async ctx => {
                 .createQueryBuilder("subscription")
                 .where("subscription.revokedAt IS NULL")
                 .innerJoin("subscription.user", "users")
-                .andWhere("users.screenName = ANY(:lusers)", { lusers: mentions })
+                .andWhere("users.displayScreenName = ANY(:lusers)", { lusers: mentions })
                 .getMany()
             const payload = {
                 post: {
                     user: {
                         id: post.user.id,
                         name: post.user.name,
-                        screenName: post.user.screenName,
+                        screenName: post.user.displayScreenName,
                         icon: icon,
                     },
                     text: post.text,

src/routers/web/login.ts

@@ -22,7 +22,7 @@ router.post("/", koaBody(), checkReCaptcha, async ctx => {
         password: $.string.compose($length({ min: 8 })),
     }).transformOrThrow(ctx.request.body)
     const user = await getRepository(User).findOne({
-        screenName: body.screen_name,
+        displayScreenName: body.screen_name,
     })
     if (user == null) return ctx.throw(400, "そんなユーザーいない")
     const checkPasswordResult = await bcrypt.compare(body.password, user.encryptedPassword)

src/routers/web/register.ts

@@ -24,6 +24,7 @@ router.post("/", koaBody(), checkReCaptcha, async ctx => {
     const user = new User()
     user.name = body.name
     user.screenName = body.screen_name
+    user.displayScreenName = body.screen_name
     user.encryptedPassword = await bcrypt.hash(body.password, 14)
     const repo = getRepository(User)
     const res = await repo.insert(user).catch(e => {

src/routers/web/settings/index.ts

@@ -2,11 +2,13 @@ import Router from "koa-router"
 import { WebRouterState, WebRouterCustom } from ".."
 import myDevelopedApplicationsRouter from "./myDevelopedApplications"
 import inviteCodesRouter from "./inviteCodes"
+import subAccountsRouter from "./subAccounts"
 
 const router = new Router<WebRouterState, WebRouterCustom>()
 
 router.use("/my_developed_applications", myDevelopedApplicationsRouter.routes())
 router.use("/invite_codes", inviteCodesRouter.routes())
+router.use("/sub_accounts", subAccountsRouter.routes())
 
 router.get("/", async ctx => {
     ctx.render("settings/index")

src/routers/web/settings/subAccounts.ts

@@ -0,0 +1,17 @@
+import Router = require("koa-router")
+import { WebRouterState, WebRouterCustom } from ".."
+import { getRepository } from "typeorm"
+import { User } from "../../../db/entities/user"
+
+const router = new Router<WebRouterState, WebRouterCustom>()
+
+router.get("/", async ctx => {
+    const session = ctx.state.session
+    if (session == null) throw "please login"
+    const subAccounts = await getRepository(User).find({
+        owner: session.user,
+    })
+    ctx.render("settings/sub_accounts/index", { subAccounts })
+})
+
+export default router