enforce unique fields

Author: erquhart

auth.ts

@@ -1,5 +1,11 @@
 import { betterAuth } from "better-auth";
-import { emailOTP, magicLink, twoFactor } from "better-auth/plugins";
+import {
+  anonymous,
+  emailOTP,
+  magicLink,
+  twoFactor,
+  username,
+} from "better-auth/plugins";
 import { convex } from "@convex-dev/better-auth/plugins";
 
 // This is the config used to generate the schema
@@ -11,14 +17,16 @@ const config = betterAuth({
     twoFactor(),
     magicLink({ sendMagicLink: async () => {} }),
     emailOTP({ sendVerificationOTP: async () => {} }),
+    anonymous(),
+    username(),
     convex(),
   ],
 });
 export { config as auth };
 
 // Set fields to index on for schema generation
 export const indexFields = {
-  user: ["email", "userId"],
+  user: ["email", "userId", "username"],
   session: ["token", "userId", "expiresAt", ["expiresAt", "userId"]],
   account: [
     "userId",

src/component/lib.ts

@@ -8,7 +8,7 @@ import { asyncMap } from "convex-helpers";
 import { v } from "convex/values";
 import { api } from "../component/_generated/api";
 import { Doc, Id, TableNames } from "../component/_generated/dataModel";
-import schema from "../component/schema";
+import schema, { specialFields } from "../component/schema";
 import { paginationOptsValidator, PaginationResult } from "convex/server";
 import { paginator } from "convex-helpers/server/pagination";
 import { partial } from "convex-helpers/validators";
@@ -70,6 +70,32 @@ export const getByQuery = query({
 });
 export { getByQuery as getBy };
 
+const checkUniqueFields = async (
+  ctx: QueryCtx,
+  table: TableNames,
+  input: Record<string, any>,
+  doc?: Doc<any>
+) => {
+  const uniqueFields = Object.entries(
+    specialFields[table as keyof typeof specialFields]
+  )
+    .filter(
+      ([key, value]) =>
+        value.unique && Object.keys(input).includes(key as keyof typeof input)
+    )
+    .map(([key]) => key);
+  for (const field of uniqueFields) {
+    const existingDoc = await getByHelper(ctx, {
+      table,
+      field,
+      value: input[field as keyof typeof input],
+    });
+    if (existingDoc && existingDoc._id !== doc?._id) {
+      throw new Error(`${table} ${field} already exists`);
+    }
+  }
+};
+
 export const create = mutation({
   args: v.object({
     input: v.union(
@@ -83,6 +109,9 @@ export const create = mutation({
   }),
   handler: async (ctx, args) => {
     const { table, ...input } = args.input;
+
+    await checkUniqueFields(ctx, table as TableNames, input);
+
     const id = await ctx.db.insert(table as any, {
       ...input,
     });
@@ -122,6 +151,7 @@ export const update = mutation({
     if (!doc) {
       throw new Error(`Failed to update ${table}`);
     }
+    await checkUniqueFields(ctx, table as TableNames, value, doc);
     await ctx.db.patch(doc._id, value as any);
     const updatedDoc = await ctx.db.get(doc._id);
     if (!updatedDoc) {

src/component/schema.ts

@@ -14,10 +14,14 @@ const schema = defineSchema({
     createdAt: v.number(),
     updatedAt: v.number(),
     twoFactorEnabled: v.optional(v.boolean()),
+    isAnonymous: v.optional(v.boolean()),
+    username: v.optional(v.string()),
+    displayUsername: v.optional(v.string()),
     userId: v.optional(v.string()),
   })
     .index("email", ["email"])
-    .index("userId", ["userId"]),
+    .index("userId", ["userId"])
+    .index("username", ["username"]),
 
   session: defineTable({
     expiresAt: v.number(),
@@ -31,7 +35,7 @@ const schema = defineSchema({
     .index("token", ["token"])
     .index("userId", ["userId"])
     .index("expiresAt", ["expiresAt"])
-    .index("expiresAt_userId", ["expiresAt","userId"]),
+    .index("expiresAt_userId", ["expiresAt", "userId"]),
 
   account: defineTable({
     accountId: v.string(),
@@ -49,8 +53,8 @@ const schema = defineSchema({
   })
     .index("userId", ["userId"])
     .index("accountId", ["accountId"])
-    .index("accountId_providerId", ["accountId","providerId"])
-    .index("providerId_userId", ["providerId","userId"]),
+    .index("accountId_providerId", ["accountId", "providerId"])
+    .index("providerId_userId", ["providerId", "userId"]),
 
   verification: defineTable({
     identifier: v.string(),
@@ -66,8 +70,7 @@ const schema = defineSchema({
     secret: v.string(),
     backupCodes: v.string(),
     userId: v.string(),
-  })
-    .index("userId", ["userId"]),
+  }).index("userId", ["userId"]),
 
   jwks: defineTable({
     publicKey: v.string(),
@@ -79,50 +82,52 @@ const schema = defineSchema({
     key: v.optional(v.string()),
     count: v.optional(v.number()),
     lastRequest: v.optional(v.number()),
-  })
-    .index("key", ["key"]),
-
+  }).index("key", ["key"]),
 });
 
 export default schema;
 
 export const specialFields = {
   user: {
     name: {
-      sortable: true
+      sortable: true,
     },
     email: {
       sortable: true,
-      unique: true
-    }
+      unique: true,
+    },
+    username: {
+      sortable: true,
+      unique: true,
+    },
   },
   session: {
     token: {
-      unique: true
+      unique: true,
     },
     userId: {
       references: {
         model: "user",
         field: "id",
-        onDelete: "cascade"
-      }
-    }
+        onDelete: "cascade",
+      },
+    },
   },
   account: {
     userId: {
       references: {
         model: "user",
         field: "id",
-        onDelete: "cascade"
-      }
-    }
+        onDelete: "cascade",
+      },
+    },
   },
   twoFactor: {
     userId: {
       references: {
         model: "user",
-        field: "id"
-      }
-    }
-  }
+        field: "id",
+      },
+    },
+  },
 };