@convex-dev/better-auth 0.8.0-alpha.9 → 0.8.0

package/src/{component/lib.ts → client/adapterUtils.ts}

@@ -1,17 +1,18 @@
-import { mutation, query, QueryCtx } from "../component/_generated/server";
 import { asyncMap } from "convex-helpers";
-import { Infer, v } from "convex/values";
-import { Doc, Id, TableNames } from "../component/_generated/dataModel";
-import schema, { specialFields } from "../component/schema";
+import { GenericId, Infer, v } from "convex/values";
 import {
+  DocumentByName,
+  GenericDataModel,
+  GenericQueryCtx,
   PaginationOptions,
-  paginationOptsValidator,
   PaginationResult,
+  SchemaDefinition,
+  TableNamesInDataModel,
 } from "convex/server";
-import { partial } from "convex-helpers/validators";
 import { stream } from "convex-helpers/server/stream";
 import { mergedStream } from "convex-helpers/server/stream";
 import { stripIndent } from "common-tags";
+import { BetterAuthDbSchema } from "better-auth/db";
 
 export const adapterWhereValidator = v.object({
   field: v.string(),
@@ -52,11 +53,15 @@ export const adapterArgsValidator = v.object({
   select: v.optional(v.array(v.string())),
   limit: v.optional(v.number()),
   offset: v.optional(v.number()),
-  unique: v.optional(v.boolean()),
 });
 
-const isUniqueField = (model: TableNames, field: string) => {
-  const fields = specialFields[model as keyof typeof specialFields];
+const isUniqueField = (
+  betterAuthSchema: BetterAuthDbSchema,
+  model: string,
+  field: string
+) => {
+  const fields =
+    betterAuthSchema[model as keyof typeof betterAuthSchema]["fields"];
   if (!fields) {
     return false;
   }
@@ -65,38 +70,45 @@ const isUniqueField = (model: TableNames, field: string) => {
     .map(([key]) => key)
     .includes(field);
 };
-const hasUniqueFields = (model: TableNames, input: Record<string, any>) => {
+export const hasUniqueFields = (
+  betterAuthSchema: BetterAuthDbSchema,
+  model: string,
+  input: Record<string, any>
+) => {
   for (const field of Object.keys(input)) {
-    if (isUniqueField(model, field)) {
+    if (isUniqueField(betterAuthSchema, model, field)) {
       return true;
     }
   }
   return false;
 };
 
-const findIndex = (args: {
-  model: string;
-  where?: {
-    field: string;
-    operator?:
-      | "lt"
-      | "lte"
-      | "gt"
-      | "gte"
-      | "eq"
-      | "in"
-      | "ne"
-      | "contains"
-      | "starts_with"
-      | "ends_with";
-    value: string | number | boolean | null | string[] | number[];
-    connector?: "AND" | "OR";
-  }[];
-  sortBy?: {
-    field: string;
-    direction: "asc" | "desc";
-  };
-}) => {
+const findIndex = (
+  schema: SchemaDefinition<any, any>,
+  args: {
+    model: string;
+    where?: {
+      field: string;
+      operator?:
+        | "lt"
+        | "lte"
+        | "gt"
+        | "gte"
+        | "eq"
+        | "in"
+        | "ne"
+        | "contains"
+        | "starts_with"
+        | "ends_with";
+      value: string | number | boolean | null | string[] | number[];
+      connector?: "AND" | "OR";
+    }[];
+    sortBy?: {
+      field: string;
+      direction: "asc" | "desc";
+    };
+  }
+) => {
   if (
     (args.where?.length ?? 0) > 1 &&
     args.where?.some((w) => w.connector === "OR")
@@ -188,7 +200,7 @@ const findIndex = (args: {
         indexDescriptor: "by_creation_time",
         fields: [],
       }
-    : indexes.find(({ fields }) => {
+    : indexes.find(({ fields }: { fields: string[] }) => {
         const fieldsMatch = indexFields.every(
           (field, idx) => field === fields[idx]
         );
@@ -220,21 +232,25 @@ const findIndex = (args: {
   };
 };
 
-const checkUniqueFields = async (
-  ctx: QueryCtx,
-  table: TableNames,
+export const checkUniqueFields = async <
+  Schema extends SchemaDefinition<any, any>,
+>(
+  ctx: GenericQueryCtx<GenericDataModel>,
+  schema: Schema,
+  betterAuthSchema: BetterAuthDbSchema,
+  table: string,
   input: Record<string, any>,
-  doc?: Doc<any>
+  doc?: Record<string, any>
 ) => {
-  if (!hasUniqueFields(table, input)) {
+  if (!hasUniqueFields(betterAuthSchema, table, input)) {
     return;
   }
   for (const field of Object.keys(input)) {
-    if (!isUniqueField(table, field)) {
+    if (!isUniqueField(betterAuthSchema, table, field)) {
       continue;
     }
     const { index } =
-      findIndex({
+      findIndex(schema, {
         model: table,
         where: [
           { field, operator: "eq", value: input[field as keyof typeof input] },
@@ -256,33 +272,17 @@ const checkUniqueFields = async (
 };
 
 // This handles basic select (stripping out the other fields if there
-// is a select arg), but also swaps in the app userId for any user id
-// reference fields.
-const selectFields = async <T extends TableNames, D extends Doc<T>>(
-  ctx: QueryCtx,
+// is a select arg).
+export const selectFields = async <
+  T extends TableNamesInDataModel<GenericDataModel>,
+  D extends DocumentByName<GenericDataModel, T>,
+>(
   doc: D | null,
   select?: string[]
 ) => {
   if (!doc) {
     return null;
   }
-  const modelSpecialFields =
-    specialFields[doc._table as keyof typeof specialFields];
-  const userIdField = modelSpecialFields
-    ? Object.entries(modelSpecialFields).find(
-        ([_, field]) => field.references?.model === "user"
-      )
-    : undefined;
-  if (userIdField) {
-    const userIdFieldName = userIdField[0] as keyof typeof doc;
-    const userId = doc[userIdFieldName];
-    if (userId) {
-      const user = await ctx.db.get(userId as unknown as Id<"user">);
-      if (user) {
-        (doc as any)[userIdFieldName] = user.userId;
-      }
-    }
-  }
   if (!select?.length) {
     return doc;
   }
@@ -295,8 +295,11 @@ const selectFields = async <T extends TableNames, D extends Doc<T>>(
 // Manually filter an individual document by where clauses. This is used to
 // simplify queries that can only return 0 or 1 documents, or "in" clauses that
 // query multiple single documents in parallel.
-const filterByWhere = (
-  doc: Doc<any>,
+const filterByWhere = <
+  T extends TableNamesInDataModel<GenericDataModel>,
+  D extends DocumentByName<GenericDataModel, T>,
+>(
+  doc: D | null,
   where?: Infer<typeof adapterWhereValidator>[],
   // Optionally filter which where clauses to apply.
   filterWhere?: (w: Infer<typeof adapterWhereValidator>) => any
@@ -374,11 +377,13 @@ const filterByWhere = (
 };
 
 const generateQuery = (
-  ctx: QueryCtx,
+  ctx: GenericQueryCtx<GenericDataModel>,
+  schema: SchemaDefinition<any, any>,
   args: Infer<typeof adapterArgsValidator>
 ) => {
-  const { index, values, boundField, indexFields } = findIndex(args) ?? {};
-  const query = stream(ctx.db, schema).query(args.model as any);
+  const { index, values, boundField, indexFields } =
+    findIndex(schema, args) ?? {};
+  const query = stream(ctx.db as any, schema).query(args.model as any);
   const hasValues =
     values?.eq?.length ||
     values?.lt ||
@@ -443,12 +448,17 @@ const generateQuery = (
 // This is the core function for reading from the database, it parses and
 // validates where conditions, selects indexes, and allows the caller to
 // optionally paginate as needed. Every response is a pagination result.
-const paginate = async (
-  ctx: QueryCtx,
+export const paginate = async <
+  Doc extends DocumentByName<GenericDataModel, T>,
+  T extends TableNamesInDataModel<GenericDataModel>,
+>(
+  ctx: GenericQueryCtx<GenericDataModel>,
+  schema: SchemaDefinition<any, any>,
+  betterAuthSchema: BetterAuthDbSchema,
   args: Infer<typeof adapterArgsValidator> & {
     paginationOpts: PaginationOptions;
   }
-): Promise<PaginationResult<Doc<any>>> => {
+): Promise<PaginationResult<Doc>> => {
   if (args.offset) {
     throw new Error(`offset not supported: ${JSON.stringify(args.offset)}`);
   }
@@ -473,17 +483,17 @@ const paginate = async (
   const uniqueWhere = args.where?.find(
     (w) =>
       (!w.operator || w.operator === "eq") &&
-      (isUniqueField(args.model as TableNames, w.field) || w.field === "id")
+      (isUniqueField(betterAuthSchema, args.model, w.field) || w.field === "id")
   );
   if (uniqueWhere) {
     const { index } =
-      findIndex({
+      findIndex(schema, {
         model: args.model,
         where: [uniqueWhere],
       }) || {};
     const doc =
       uniqueWhere.field === "id"
-        ? await ctx.db.get(uniqueWhere.value as Id<TableNames>)
+        ? await ctx.db.get(uniqueWhere.value as GenericId<T>)
         : await ctx.db
             .query(args.model as any)
             .withIndex(index?.indexDescriptor as any, (q) =>
@@ -494,7 +504,7 @@ const paginate = async (
     // Apply all other clauses as static filters to our 0 or 1 result.
     if (filterByWhere(doc, args.where, (w) => w !== uniqueWhere)) {
       return {
-        page: [await selectFields(ctx, doc, args.select)].filter(Boolean),
+        page: [await selectFields(doc, args.select)].filter(Boolean) as Doc[],
         isDone: true,
         continueCursor: "",
       };
@@ -525,18 +535,18 @@ const paginate = async (
     // For ids, just use asyncMap + .get()
     if (inWhere.field === "id") {
       const docs = await asyncMap(inWhere.value as any[], async (value) => {
-        return ctx.db.get(value as Id<TableNames>);
+        return ctx.db.get(value as GenericId<T>);
       });
       const filteredDocs = docs
-        .flatMap((doc) => doc || [])
+        .flatMap((doc) => (doc ? [doc] : []))
         .filter((doc) => filterByWhere(doc, args.where, (w) => w !== inWhere));
 
       return {
         page: filteredDocs.sort((a, b) => {
           if (args.sortBy?.field === "createdAt") {
             return args.sortBy.direction === "asc"
-              ? a._creationTime - b._creationTime
-              : b._creationTime - a._creationTime;
+              ? (a._creationTime as number) - (b._creationTime as number)
+              : (b._creationTime as number) - (a._creationTime as number);
           }
           if (args.sortBy) {
             const aValue = a[args.sortBy.field as keyof typeof a];
@@ -545,21 +555,21 @@ const paginate = async (
               return 0;
             }
             return args.sortBy.direction === "asc"
-              ? aValue > bValue
+              ? aValue! > bValue!
                 ? 1
                 : -1
-              : aValue > bValue
+              : aValue! > bValue!
                 ? -1
                 : 1;
           }
           return 0;
-        }),
+        }) as Doc[],
         isDone: true,
         continueCursor: "",
       };
     }
     const streams = inWhere.value.map((value) => {
-      return generateQuery(ctx, {
+      return generateQuery(ctx, schema, {
         ...args,
         where: args.where?.map((w) => {
           if (w === inWhere) {
@@ -579,195 +589,35 @@ const paginate = async (
     return {
       ...result,
       page: await asyncMap(result.page, (doc) =>
-        selectFields(ctx, doc, args.select)
+        selectFields(doc, args.select)
       ),
     };
   }
 
-  const query = generateQuery(ctx, args);
+  const query = generateQuery(ctx, schema, args);
   const result = await query.paginate(paginationOpts);
   return {
     ...result,
-    page: await asyncMap(result.page, (doc) =>
-      selectFields(ctx, doc, args.select)
-    ),
+    page: await asyncMap(result.page, (doc) => selectFields(doc, args.select)),
   };
 };
 
-const listOne = async (
-  ctx: QueryCtx,
+export const listOne = async <
+  Doc extends DocumentByName<GenericDataModel, T>,
+  T extends TableNamesInDataModel<GenericDataModel>,
+>(
+  ctx: GenericQueryCtx<GenericDataModel>,
+  schema: SchemaDefinition<any, any>,
+  betterAuthSchema: BetterAuthDbSchema,
   args: Infer<typeof adapterArgsValidator>
-): Promise<Doc<any> | null> => {
+): Promise<Doc | null> => {
   return (
-    await paginate(ctx, {
+    await paginate(ctx, schema, betterAuthSchema, {
       ...args,
       paginationOpts: {
         numItems: 1,
         cursor: null,
       },
     })
-  ).page[0];
+  ).page[0] as Doc | null;
 };
-
-export const create = mutation({
-  args: {
-    input: v.union(
-      ...Object.entries(schema.tables).map(([model, table]) =>
-        v.object({
-          model: v.literal(model),
-          data: v.object(table.validator.fields),
-        })
-      )
-    ),
-  },
-  handler: async (ctx, args) => {
-    await checkUniqueFields(
-      ctx,
-      args.input.model as TableNames,
-      args.input.data
-    );
-
-    const id = await ctx.db.insert(args.input.model as any, args.input.data);
-    const doc = await ctx.db.get(id);
-    if (!doc) {
-      throw new Error(`Failed to create ${args.input.model}`);
-    }
-    return doc;
-  },
-});
-
-export const findOne = query({
-  args: adapterArgsValidator,
-  handler: async (ctx, args) => {
-    return listOne(ctx, args);
-  },
-});
-
-export const findMany = query({
-  args: {
-    ...adapterArgsValidator.fields,
-    paginationOpts: paginationOptsValidator,
-  },
-  handler: async (ctx, args) => {
-    return await paginate(ctx, args);
-  },
-});
-
-export const updateOne = mutation({
-  args: {
-    input: v.union(
-      ...Object.entries(schema.tables).map(([model, table]) =>
-        v.object({
-          model: v.literal(model),
-          where: v.optional(v.array(adapterWhereValidator)),
-          update: v.object(partial(table.validator.fields)),
-        })
-      )
-    ),
-  },
-  handler: async (ctx, args) => {
-    const doc = await listOne(ctx, args.input);
-    if (!doc) {
-      throw new Error(`Failed to update ${args.input.model}`);
-    }
-    await checkUniqueFields(
-      ctx,
-      args.input.model as TableNames,
-      args.input.update,
-      doc
-    );
-    await ctx.db.patch(doc._id, args.input.update as any);
-    const updatedDoc = await ctx.db.get(doc._id);
-    if (!updatedDoc) {
-      throw new Error(`Failed to update ${args.input.model}`);
-    }
-    return updatedDoc;
-  },
-});
-
-export const updateMany = mutation({
-  args: {
-    input: v.union(
-      ...Object.entries(schema.tables).map(([model, table]) =>
-        v.object({
-          ...adapterArgsValidator.fields,
-          model: v.literal(model),
-          where: v.optional(v.array(adapterWhereValidator)),
-          update: v.object(partial(table.validator.fields)),
-          paginationOpts: paginationOptsValidator,
-        })
-      )
-    ),
-  },
-  handler: async (ctx, args) => {
-    const { page, ...result } = await paginate(ctx, args.input);
-    if (args.input.update) {
-      if (
-        hasUniqueFields(
-          args.input.model as TableNames,
-          args.input.update ?? {}
-        ) &&
-        page.length > 1
-      ) {
-        throw new Error(
-          `Attempted to set unique fields in multiple documents in ${args.input.model} with the same value. Fields: ${Object.keys(args.input.update ?? {}).join(", ")}`
-        );
-      }
-      await asyncMap(page, async (doc) => {
-        await checkUniqueFields(
-          ctx,
-          args.input.model as TableNames,
-          args.input.update ?? {},
-          doc
-        );
-        await ctx.db.patch(doc._id, args.input.update as any);
-      });
-    }
-    return {
-      ...result,
-      count: page.length,
-    };
-  },
-});
-
-export const deleteOne = mutation({
-  args: adapterArgsValidator,
-  handler: async (ctx, args) => {
-    const doc = await listOne(ctx, args);
-    if (!doc) {
-      return;
-    }
-    await ctx.db.delete(doc._id);
-    return doc;
-  },
-});
-
-export const deleteMany = mutation({
-  args: {
-    ...adapterArgsValidator.fields,
-    paginationOpts: paginationOptsValidator,
-  },
-  handler: async (ctx, args) => {
-    const { page, ...result } = await paginate(ctx, args);
-    await asyncMap(page, async (doc) => {
-      await ctx.db.delete(doc._id);
-    });
-    return {
-      ...result,
-      count: page.length,
-    };
-  },
-});
-
-// Get the session via sessionId in jwt claims
-// TODO: this needs a refresh, subquery only necessary for actions
-export const getCurrentSession = query({
-  args: {},
-  handler: async (ctx) => {
-    const identity = await ctx.auth.getUserIdentity();
-    if (!identity) {
-      return null;
-    }
-    return ctx.db.get(identity.sessionId as Id<"session">);
-  },
-});

package/src/client/createSchema.ts

@@ -0,0 +1,149 @@
+import { BetterAuthDbSchema, type FieldAttribute } from "better-auth/db";
+
+// Manually add fields to index on for schema generation,
+// all fields in the schema specialFields are automatically indexed
+export const indexFields = {
+  account: ["accountId", ["accountId", "providerId"], ["providerId", "userId"]],
+  rateLimit: ["key"],
+  session: ["expiresAt", ["expiresAt", "userId"]],
+  verification: ["expiresAt", "identifier"],
+  user: [["email", "name"], "name", "userId"],
+  passkey: ["credentialID"],
+  apikey: ["key"],
+  member: [["organizationId", "userId"]],
+  invitation: [
+    ["email", "organizationId", "status"],
+    ["organizationId", "status"],
+  ],
+  oauthConsent: [["clientId", "userId"]],
+  ssoProvider: ["organizationId", "domain"],
+  subscription: ["stripeSubscriptionId", "stripeCustomerId", "referenceId"],
+};
+
+// Return map of unique, sortable, and reference fields
+const specialFields = (tables: BetterAuthDbSchema) =>
+  Object.fromEntries(
+    Object.entries(tables)
+      .map(([key, table]) => {
+        const fields = Object.fromEntries(
+          Object.entries(table.fields)
+            .map(([fieldKey, field]) => [
+              fieldKey,
+              {
+                ...(field.sortable ? { sortable: true } : {}),
+                ...(field.unique ? { unique: true } : {}),
+                ...(field.references ? { references: field.references } : {}),
+              },
+            ])
+            .filter(([_key, value]) =>
+              typeof value === "object" ? Object.keys(value).length > 0 : true
+            )
+        );
+        return [key, fields];
+      })
+      .filter(([_key, value]) =>
+        typeof value === "object" ? Object.keys(value).length > 0 : true
+      )
+  );
+
+const mergedIndexFields = (tables: BetterAuthDbSchema) =>
+  Object.fromEntries(
+    Object.entries(tables).map(([key]) => {
+      const manualIndexes = indexFields[key as keyof typeof indexFields] || [];
+      const specialFieldIndexes = Object.keys(
+        specialFields(tables)[key as keyof ReturnType<typeof specialFields>] ||
+          {}
+      ).filter(
+        (index) =>
+          !manualIndexes.some((m) =>
+            Array.isArray(m) ? m[0] === index : m === index
+          )
+      );
+      return [key, manualIndexes.concat(specialFieldIndexes)];
+    })
+  );
+
+export const createSchema = async ({
+  file,
+  tables,
+}: {
+  tables: BetterAuthDbSchema;
+  file?: string;
+}) => {
+  process.env.IS_GENERATING_SCHEMA = "1";
+  let code: string = `// This file is auto-generated. Do not edit this file manually.
+// To regenerate the schema, run:
+// \`npx @better-auth/cli generate --output ${file} -y\`
+
+import { defineSchema, defineTable } from "convex/server";
+import { v } from "convex/values";
+
+export const tables = {
+`;
+
+  for (const tableKey in tables) {
+    const table = tables[tableKey]!;
+    const modelName = table.modelName;
+
+    // No id fields in Convex schema
+    const fields = Object.fromEntries(
+      Object.entries(table.fields).filter(([key]) => key !== "id")
+    );
+
+    function getType(name: string, field: FieldAttribute) {
+      const type = field.type as
+        | "string"
+        | "number"
+        | "boolean"
+        | "date"
+        | `${"string" | "number"}[]`;
+
+      const typeMap: Record<typeof type, string> = {
+        string: `v.string()`,
+        boolean: `v.boolean()`,
+        number: `v.number()`,
+        date: `v.number()`,
+        "number[]": `v.array(v.number())`,
+        "string[]": `v.array(v.string())`,
+      } as const;
+      return typeMap[type];
+    }
+
+    const indexes =
+      mergedIndexFields(tables)[
+        modelName as keyof typeof mergedIndexFields
+      ]?.map((index) => {
+        const indexArray = Array.isArray(index) ? index.sort() : [index];
+        const indexName = indexArray.join("_");
+        return `.index("${indexName}", ${JSON.stringify(indexArray)})`;
+      }) || [];
+
+    const schema = `${modelName}: defineTable({
+${Object.keys(fields)
+  .map((field) => {
+    const attr = fields[field]!;
+    const type = getType(field, attr as FieldAttribute);
+    const optional = (fieldSchema: string) =>
+      attr.required
+        ? fieldSchema
+        : `v.optional(v.union(v.null(), ${fieldSchema}))`;
+    return `    ${field}: ${optional(type)},`;
+  })
+  .join("\n")}
+  })${indexes.length > 0 ? `\n    ${indexes.join("\n    ")}` : ""},\n`;
+    code += `  ${schema}`;
+  }
+
+  code += `};
+
+const schema = defineSchema(tables);
+
+export default schema;
+`;
+
+  return {
+    code,
+    path: file ?? "./schema.ts",
+    overwrite: true,
+  };
+};