@convex-dev/better-auth 0.6.0

package/src/component/_generated/dataModel.d.ts

@@ -0,0 +1,60 @@
+/* eslint-disable */
+/**
+ * Generated data model types.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type {
+  DataModelFromSchemaDefinition,
+  DocumentByName,
+  TableNamesInDataModel,
+  SystemTableNames,
+} from "convex/server";
+import type { GenericId } from "convex/values";
+import schema from "../schema.js";
+
+/**
+ * The names of all of your Convex tables.
+ */
+export type TableNames = TableNamesInDataModel<DataModel>;
+
+/**
+ * The type of a document stored in Convex.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Doc<TableName extends TableNames> = DocumentByName<
+  DataModel,
+  TableName
+>;
+
+/**
+ * An identifier for a document in Convex.
+ *
+ * Convex documents are uniquely identified by their `Id`, which is accessible
+ * on the `_id` field. To learn more, see [Document IDs](https://docs.convex.dev/using/document-ids).
+ *
+ * Documents can be loaded using `db.get(id)` in query and mutation functions.
+ *
+ * IDs are just strings at runtime, but this type can be used to distinguish them from other
+ * strings when type checking.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Id<TableName extends TableNames | SystemTableNames> =
+  GenericId<TableName>;
+
+/**
+ * A type describing your Convex data model.
+ *
+ * This type includes information about what tables you have, the type of
+ * documents stored in those tables, and the indexes defined on them.
+ *
+ * This type is used to parameterize methods like `queryGeneric` and
+ * `mutationGeneric` to make them type-safe.
+ */
+export type DataModel = DataModelFromSchemaDefinition<typeof schema>;

package/src/component/_generated/server.d.ts

@@ -0,0 +1,149 @@
+/* eslint-disable */
+/**
+ * Generated utilities for implementing server-side Convex query and mutation functions.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import {
+  ActionBuilder,
+  AnyComponents,
+  HttpActionBuilder,
+  MutationBuilder,
+  QueryBuilder,
+  GenericActionCtx,
+  GenericMutationCtx,
+  GenericQueryCtx,
+  GenericDatabaseReader,
+  GenericDatabaseWriter,
+  FunctionReference,
+} from "convex/server";
+import type { DataModel } from "./dataModel.js";
+
+type GenericCtx =
+  | GenericActionCtx<DataModel>
+  | GenericMutationCtx<DataModel>
+  | GenericQueryCtx<DataModel>;
+
+/**
+ * Define a query in this Convex app's public API.
+ *
+ * This function will be allowed to read your Convex database and will be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export declare const query: QueryBuilder<DataModel, "public">;
+
+/**
+ * Define a query that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to read from your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export declare const internalQuery: QueryBuilder<DataModel, "internal">;
+
+/**
+ * Define a mutation in this Convex app's public API.
+ *
+ * This function will be allowed to modify your Convex database and will be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export declare const mutation: MutationBuilder<DataModel, "public">;
+
+/**
+ * Define a mutation that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to modify your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export declare const internalMutation: MutationBuilder<DataModel, "internal">;
+
+/**
+ * Define an action in this Convex app's public API.
+ *
+ * An action is a function which can execute any JavaScript code, including non-deterministic
+ * code and code with side-effects, like calling third-party services.
+ * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive.
+ * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.
+ *
+ * @param func - The action. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
+ */
+export declare const action: ActionBuilder<DataModel, "public">;
+
+/**
+ * Define an action that is only accessible from other Convex functions (but not from the client).
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
+ */
+export declare const internalAction: ActionBuilder<DataModel, "internal">;
+
+/**
+ * Define an HTTP action.
+ *
+ * This function will be used to respond to HTTP requests received by a Convex
+ * deployment if the requests matches the path and method where this action
+ * is routed. Be sure to route your action in `convex/http.js`.
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
+ */
+export declare const httpAction: HttpActionBuilder;
+
+/**
+ * A set of services for use within Convex query functions.
+ *
+ * The query context is passed as the first argument to any Convex query
+ * function run on the server.
+ *
+ * This differs from the {@link MutationCtx} because all of the services are
+ * read-only.
+ */
+export type QueryCtx = GenericQueryCtx<DataModel>;
+
+/**
+ * A set of services for use within Convex mutation functions.
+ *
+ * The mutation context is passed as the first argument to any Convex mutation
+ * function run on the server.
+ */
+export type MutationCtx = GenericMutationCtx<DataModel>;
+
+/**
+ * A set of services for use within Convex action functions.
+ *
+ * The action context is passed as the first argument to any Convex action
+ * function run on the server.
+ */
+export type ActionCtx = GenericActionCtx<DataModel>;
+
+/**
+ * An interface to read from the database within Convex query functions.
+ *
+ * The two entry points are {@link DatabaseReader.get}, which fetches a single
+ * document by its {@link Id}, or {@link DatabaseReader.query}, which starts
+ * building a query.
+ */
+export type DatabaseReader = GenericDatabaseReader<DataModel>;
+
+/**
+ * An interface to read from and write to the database within Convex mutation
+ * functions.
+ *
+ * Convex guarantees that all writes within a single mutation are
+ * executed atomically, so you never have to worry about partial writes leaving
+ * your data in an inconsistent state. See [the Convex Guide](https://docs.convex.dev/understanding/convex-fundamentals/functions#atomicity-and-optimistic-concurrency-control)
+ * for the guarantees Convex provides your functions.
+ */
+export type DatabaseWriter = GenericDatabaseWriter<DataModel>;

package/src/component/_generated/server.js

@@ -0,0 +1,90 @@
+/* eslint-disable */
+/**
+ * Generated utilities for implementing server-side Convex query and mutation functions.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import {
+  actionGeneric,
+  httpActionGeneric,
+  queryGeneric,
+  mutationGeneric,
+  internalActionGeneric,
+  internalMutationGeneric,
+  internalQueryGeneric,
+  componentsGeneric,
+} from "convex/server";
+
+/**
+ * Define a query in this Convex app's public API.
+ *
+ * This function will be allowed to read your Convex database and will be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const query = queryGeneric;
+
+/**
+ * Define a query that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to read from your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const internalQuery = internalQueryGeneric;
+
+/**
+ * Define a mutation in this Convex app's public API.
+ *
+ * This function will be allowed to modify your Convex database and will be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const mutation = mutationGeneric;
+
+/**
+ * Define a mutation that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to modify your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const internalMutation = internalMutationGeneric;
+
+/**
+ * Define an action in this Convex app's public API.
+ *
+ * An action is a function which can execute any JavaScript code, including non-deterministic
+ * code and code with side-effects, like calling third-party services.
+ * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive.
+ * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.
+ *
+ * @param func - The action. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
+ */
+export const action = actionGeneric;
+
+/**
+ * Define an action that is only accessible from other Convex functions (but not from the client).
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
+ */
+export const internalAction = internalActionGeneric;
+
+/**
+ * Define a Convex HTTP action.
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument, and a `Request` object
+ * as its second.
+ * @returns The wrapped endpoint function. Route a URL path to this function in `convex/http.js`.
+ */
+export const httpAction = httpActionGeneric;

package/src/component/convex.config.ts

@@ -0,0 +1,5 @@
+import { defineComponent } from "convex/server";
+
+const component = defineComponent("betterAuth");
+
+export default component;

package/src/component/lib.ts

@@ -0,0 +1,391 @@
+import {
+  action,
+  mutation,
+  query,
+  QueryCtx,
+} from "../component/_generated/server";
+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 { paginationOptsValidator, PaginationResult } from "convex/server";
+import { paginator } from "convex-helpers/server/pagination";
+import { partial } from "convex-helpers/validators";
+
+export const transformInput = (model: string, data: Record<string, any>) => {
+  return {
+    ...Object.fromEntries(
+      Object.entries(data).map(([key, value]) => {
+        if (value instanceof Date) {
+          return [key, value.getTime()];
+        }
+        return [key, value];
+      })
+    ),
+  };
+};
+
+export const transformOutput = (
+  { _id, _creationTime, ...data }: Doc<TableNames>,
+  _model: string
+) => {
+  // Provide the expected id field, but it can be overwritten if
+  // the model has an id field
+  return { id: _id, ...data };
+};
+
+// Get the session via sessionId in jwt claims
+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">);
+  },
+});
+
+export const getByHelper = async (
+  ctx: QueryCtx,
+  args: {
+    table: string;
+    field: string;
+    value: any;
+    unique?: boolean;
+  }
+) => {
+  if (args.field === "id") {
+    return ctx.db.get(args.value);
+  }
+  const query = ctx.db
+    .query(args.table as any)
+    .withIndex(args.field as any, (q) => q.eq(args.field, args.value));
+  return args.unique ? await query.unique() : await query.first();
+};
+
+export const getByArgsValidator = {
+  table: v.string(),
+  field: v.string(),
+  unique: v.optional(v.boolean()),
+  value: v.union(
+    v.string(),
+    v.number(),
+    v.boolean(),
+    v.array(v.string()),
+    v.array(v.number()),
+    v.null()
+  ),
+};
+
+// Generic functions
+export const getByQuery = query({
+  args: getByArgsValidator,
+  handler: async (ctx, args) => {
+    const doc = await getByHelper(ctx, args);
+    if (!doc) {
+      return;
+    }
+    return transformOutput(doc, args.table);
+  },
+});
+export { getByQuery as getBy };
+
+export const create = mutation({
+  args: v.object({
+    input: v.union(
+      ...Object.values(schema.tables).map((table) =>
+        v.object({
+          table: v.string(),
+          ...table.validator.fields,
+        })
+      )
+    ),
+  }),
+  handler: async (ctx, args) => {
+    const { table, ...input } = args.input;
+    const id = await ctx.db.insert(table as any, {
+      ...input,
+    });
+    const doc = await ctx.db.get(id);
+    if (!doc) {
+      throw new Error(`Failed to create ${table}`);
+    }
+    return transformOutput(doc, table);
+  },
+});
+
+export const updateArgsInputValidator = <T extends TableNames>(table: T) => {
+  return v.object({
+    table: v.literal(table),
+    where: v.object({ field: v.string(), value: getByArgsValidator.value }),
+    value: v.record(v.string(), v.any()),
+  });
+};
+
+const updateArgsValidator = {
+  input: v.union(
+    updateArgsInputValidator("account"),
+    updateArgsInputValidator("session"),
+    updateArgsInputValidator("verification"),
+    updateArgsInputValidator("user")
+  ),
+};
+
+export const update = mutation({
+  args: updateArgsValidator,
+  handler: async (ctx, args) => {
+    const { table, where, value } = args.input;
+    const doc =
+      where.field === "id"
+        ? await ctx.db.get(where.value as Id<any>)
+        : await getByHelper(ctx, { table, ...where });
+    if (!doc) {
+      throw new Error(`Failed to update ${table}`);
+    }
+    await ctx.db.patch(doc._id, value as any);
+    const updatedDoc = await ctx.db.get(doc._id);
+    if (!updatedDoc) {
+      throw new Error(`Failed to update ${table}`);
+    }
+    return transformOutput(updatedDoc, table);
+  },
+});
+
+export const deleteBy = mutation({
+  args: getByArgsValidator,
+  handler: async (ctx, args) => {
+    const doc = await getByHelper(ctx, args);
+    if (!doc) {
+      return;
+    }
+    await ctx.db.delete(doc._id);
+    // onDeleteUser requires userId from the doc,
+    // so just return the whole thing
+    return doc;
+  },
+});
+
+// Single purpose functions
+export const getAccountsByUserId = query({
+  args: { userId: v.string(), limit: v.optional(v.number()) },
+  handler: async (ctx, args) => {
+    const query = ctx.db
+      .query("account")
+      .withIndex("userId", (q) => q.eq("userId", args.userId));
+    const docs = args.limit
+      ? await query.take(args.limit)
+      : await query.collect();
+    return docs.map((doc) => transformOutput(doc, "account"));
+  },
+});
+
+export const getJwks = query({
+  args: {
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const query = ctx.db.query("jwks");
+    const docs = args.limit
+      ? await query.take(args.limit)
+      : await query.collect();
+    return docs.map((doc) => transformOutput(doc, "jwks"));
+  },
+});
+
+export const listVerificationsByIdentifier = query({
+  args: {
+    identifier: v.string(),
+    sortBy: v.optional(
+      v.object({
+        field: v.string(),
+        direction: v.union(v.literal("asc"), v.literal("desc")),
+      })
+    ),
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    if (args.sortBy && args.sortBy.field !== "createdAt") {
+      throw new Error(`Unsupported sortBy field: ${args.sortBy.field}`);
+    }
+    const query = ctx.db
+      .query("verification")
+      .withIndex("identifier", (q) => q.eq("identifier", args.identifier))
+      .order(
+        args.sortBy?.field === "createdAt" && args.sortBy?.direction
+          ? args.sortBy.direction
+          : "asc"
+      );
+    const docs = args.limit
+      ? await query.take(args.limit)
+      : await query.collect();
+    return docs.map((doc) => transformOutput(doc, "verification"));
+  },
+});
+
+export const deleteOldVerificationsPage = mutation({
+  args: {
+    currentTimestamp: v.number(),
+    paginationOpts: v.optional(paginationOptsValidator),
+  },
+  handler: async (ctx, args) => {
+    const paginationOpts = args.paginationOpts ?? {
+      numItems: 500,
+      cursor: null,
+    };
+    const { page, ...result } = await paginator(ctx.db, schema)
+      .query("verification")
+      .withIndex("expiresAt", (q) => q.lt("expiresAt", args.currentTimestamp))
+      .paginate(paginationOpts);
+    await asyncMap(page, async (doc) => {
+      await ctx.db.delete(doc._id);
+    });
+    return { ...result, count: page.length };
+  },
+});
+
+export const deleteOldVerifications = action({
+  args: {
+    currentTimestamp: v.number(),
+  },
+  handler: async (ctx, args) => {
+    let count = 0;
+    let cursor = null;
+    let isDone = false;
+    do {
+      const result: Omit<PaginationResult<Doc<"verification">>, "page"> & {
+        count: number;
+      } = await ctx.runMutation(api.lib.deleteOldVerificationsPage, {
+        currentTimestamp: args.currentTimestamp,
+        paginationOpts: {
+          numItems: 500,
+          cursor,
+        },
+      });
+      count += result.count;
+      cursor =
+        result.pageStatus &&
+        result.splitCursor &&
+        ["SplitRecommended", "SplitRequired"].includes(result.pageStatus)
+          ? result.splitCursor
+          : result.continueCursor;
+      isDone = result.isDone;
+    } while (!isDone);
+    return count;
+  },
+});
+
+export const deleteAllForUserPage = mutation({
+  args: {
+    table: v.string(),
+    userId: v.string(),
+    paginationOpts: v.optional(paginationOptsValidator),
+  },
+  handler: async (ctx, args) => {
+    const paginationOpts = args.paginationOpts ?? {
+      numItems: 500,
+      cursor: null,
+    };
+    const { page, ...result } = await paginator(ctx.db, schema)
+      .query(args.table as any)
+      .withIndex("userId", (q) => q.eq("userId", args.userId))
+      .paginate(paginationOpts);
+    await asyncMap(page, async (doc) => {
+      await ctx.db.delete(doc._id);
+    });
+    return { ...result, count: page.length };
+  },
+});
+
+export const deleteAllForUser = action({
+  args: {
+    table: v.string(),
+    userId: v.string(),
+  },
+  handler: async (ctx, args) => {
+    let count = 0;
+    let cursor = null;
+    let isDone = false;
+    do {
+      const result: Omit<PaginationResult<Doc<"session">>, "page"> & {
+        count: number;
+      } = await ctx.runMutation(api.lib.deleteAllForUserPage, {
+        table: args.table,
+        userId: args.userId,
+        paginationOpts: {
+          numItems: 500,
+          cursor,
+        },
+      });
+      count += result.count;
+      cursor =
+        result.pageStatus &&
+        result.splitCursor &&
+        ["SplitRecommended", "SplitRequired"].includes(result.pageStatus)
+          ? result.splitCursor
+          : result.continueCursor;
+      isDone = result.isDone;
+    } while (!isDone);
+    return count;
+  },
+});
+
+export const getAccountByAccountIdAndProviderId = query({
+  args: { accountId: v.string(), providerId: v.string() },
+  handler: async (ctx, args) => {
+    const doc = await ctx.db
+      .query("account")
+      .withIndex("providerId_accountId", (q) =>
+        q.eq("providerId", args.providerId).eq("accountId", args.accountId)
+      )
+      .unique();
+    if (!doc) {
+      return;
+    }
+    return transformOutput(doc, "account");
+  },
+});
+
+export const updateUserProviderAccounts = mutation({
+  args: {
+    userId: v.string(),
+    providerId: v.string(),
+    update: v.object(partial(schema.tables.account.validator.fields)),
+  },
+  handler: async (ctx, args) => {
+    const docs = await ctx.db
+      .query("account")
+      .withIndex("userId_providerId", (q) =>
+        q.eq("userId", args.userId).eq("providerId", args.providerId)
+      )
+      .collect();
+    if (docs.length === 0) {
+      return 0;
+    }
+    await asyncMap(docs, async (doc) => {
+      await ctx.db.patch(doc._id, args.update);
+    });
+    return docs.length;
+  },
+});
+
+export const updateTwoFactor = mutation({
+  args: {
+    userId: v.string(),
+    update: v.object(partial(schema.tables.twoFactor.validator.fields)),
+  },
+  handler: async (ctx, args) => {
+    const docs = await ctx.db
+      .query("twoFactor")
+      .withIndex("userId", (q) => q.eq("userId", args.userId))
+      .collect();
+    if (docs.length === 0) {
+      return 0;
+    }
+    await asyncMap(docs, async (doc) => {
+      await ctx.db.patch(doc._id, args.update);
+    });
+    return docs.length;
+  },
+});