@neutralauth/internal-auth 0.10.11

package/src/component/adapterTest.ts

@@ -0,0 +1,505 @@
+import { createClient } from "../client/index.js";
+import type { GenericCtx } from "../client/index.js";
+import { api } from "./_generated/api.js";
+import { action } from "./_generated/server.js";
+import type { GenericActionCtx } from "convex/server";
+import type { DataModel } from "./_generated/dataModel.js";
+import type { BetterAuthOptions } from "better-auth";
+import type { EmptyObject } from "convex-helpers";
+
+// Hide vitest imports from esbuild, keep them out of the bundle
+import type {
+  beforeEach as beforeEachType,
+  test as testType,
+  expect as expectType,
+} from "vitest";
+import type { runAdapterTest as runAdapterTestType } from "better-auth/adapters/test";
+
+const getTestImports = async () => {
+  const vitestImportName = "vitest";
+  const { beforeEach, test, expect } = await import(vitestImportName);
+  const betterAuthAdaptersTestImportName = "better-auth/adapters/test";
+  const { runAdapterTest } = await import(betterAuthAdaptersTestImportName);
+  return { beforeEach, test, expect, runAdapterTest } as {
+    beforeEach: typeof beforeEachType;
+    test: typeof testType;
+    expect: typeof expectType;
+    runAdapterTest: typeof runAdapterTestType;
+  };
+};
+
+export const getAdapter: (
+  ctx: GenericCtx<DataModel>
+) => Parameters<typeof runAdapterTestType>[0]["getAdapter"] =
+  (ctx: GenericCtx<DataModel>) =>
+  async (opts?: Omit<BetterAuthOptions, "database">) => {
+    const authComponent = createClient<DataModel>(api as any, {
+      verbose: false,
+    });
+    const adapterFactory = authComponent.adapter(ctx);
+    const options = {
+      ...(opts ?? {}),
+      user: {
+        ...(opts?.user ?? {}),
+        // We don't currently support custom schema for tests, need to find a
+        // way to do this.
+        fields: undefined,
+      },
+    };
+    return adapterFactory(options);
+  };
+
+// Tests need to run inside of a Convex function to use the Convex adapter
+export const runTests = action(
+  async (
+    ctx: GenericActionCtx<DataModel>,
+    args: { disableTests: Record<string, boolean> }
+  ) => {
+    const { runAdapterTest } = await getTestImports();
+    runAdapterTest({
+      getAdapter: getAdapter(ctx),
+      disableTests: args.disableTests,
+    });
+  }
+);
+
+export const runCustomTests = action(
+  async (ctx: GenericActionCtx<DataModel>, _args: EmptyObject) => {
+    const { beforeEach, test, expect } = await getTestImports();
+    runCustomAdapterTests({
+      beforeEach,
+      test,
+      expect,
+      getAdapter: getAdapter(ctx),
+    });
+  }
+);
+
+function runCustomAdapterTests({
+  beforeEach,
+  test,
+  expect,
+  getAdapter,
+}: {
+  getAdapter: Parameters<typeof runAdapterTestType>[0]["getAdapter"];
+  beforeEach: typeof beforeEachType;
+  test: typeof testType;
+  expect: typeof expectType;
+}) {
+  beforeEach(async () => {
+    const adapter = await getAdapter();
+    await adapter.deleteMany({
+      model: "user",
+      where: [],
+    });
+    await adapter.deleteMany({
+      model: "session",
+      where: [],
+    });
+  });
+  test("should handle lone range operators", async () => {
+    const adapter = await getAdapter();
+    const user = await adapter.create({
+      model: "user",
+      data: {
+        name: "ab",
+        email: "a@a.com",
+      },
+    });
+    expect(
+      await adapter.findMany({
+        model: "user",
+        where: [
+          {
+            field: "name",
+            operator: "lt",
+            value: "a",
+          },
+        ],
+      })
+    ).toEqual([]);
+    expect(
+      await adapter.findMany({
+        model: "user",
+        where: [
+          {
+            field: "name",
+            operator: "lte",
+            value: "a",
+          },
+        ],
+      })
+    ).toEqual([]);
+    expect(
+      await adapter.findMany({
+        model: "user",
+        where: [
+          {
+            field: "name",
+            operator: "gt",
+            value: "a",
+          },
+        ],
+      })
+    ).toEqual([user]);
+    expect(
+      await adapter.findMany({
+        model: "user",
+        where: [
+          {
+            field: "name",
+            operator: "gte",
+            value: "ab",
+          },
+        ],
+      })
+    ).toEqual([user]);
+  });
+
+  test("should handle compound indexes that include id field", async () => {
+    const adapter = await getAdapter();
+    const user = await adapter.create({
+      model: "user",
+      data: {
+        name: "foo",
+        email: "foo@bar.com",
+      },
+    });
+    expect(
+      await adapter.findOne({
+        model: "user",
+        where: [
+          {
+            field: "id",
+            value: user.id,
+          },
+          {
+            field: "name",
+            value: "wrong name",
+          },
+        ],
+      })
+    ).toEqual(null);
+    expect(
+      await adapter.findOne({
+        model: "user",
+        where: [
+          {
+            field: "id",
+            value: user.id,
+          },
+          {
+            field: "name",
+            value: "foo",
+          },
+        ],
+      })
+    ).toEqual(user);
+    expect(
+      await adapter.findOne({
+        model: "user",
+        where: [
+          {
+            field: "id",
+            value: user.id,
+          },
+          {
+            field: "name",
+            value: "foo",
+            operator: "lt",
+          },
+        ],
+      })
+    ).toEqual(null);
+    expect(
+      await adapter.findOne({
+        model: "user",
+        where: [
+          {
+            field: "id",
+            value: user.id,
+          },
+          {
+            field: "name",
+            value: "foo",
+            operator: "lte",
+          },
+        ],
+      })
+    ).toEqual(user);
+    expect(
+      await adapter.findOne({
+        model: "user",
+        where: [
+          {
+            field: "id",
+            value: user.id,
+          },
+          {
+            field: "name",
+            value: "foo",
+            operator: "gt",
+          },
+        ],
+      })
+    ).toEqual(null);
+    expect(
+      await adapter.findOne({
+        model: "user",
+        where: [
+          {
+            field: "id",
+            value: user.id,
+          },
+          {
+            field: "name",
+            value: "foo",
+            operator: "gte",
+          },
+        ],
+      })
+    ).toEqual(user);
+    expect(
+      await adapter.findOne({
+        model: "user",
+        where: [
+          {
+            field: "id",
+            value: user.id,
+          },
+          {
+            field: "name",
+            operator: "in",
+            value: ["wrong", "name"],
+          },
+        ],
+      })
+    ).toEqual(null);
+    expect(
+      await adapter.findOne({
+        model: "user",
+        where: [
+          {
+            field: "id",
+            value: user.id,
+          },
+          {
+            field: "name",
+            operator: "in",
+            value: ["foo"],
+          },
+        ],
+      })
+    ).toEqual(user);
+  });
+  test("should automatically paginate", async () => {
+    const adapter = await getAdapter();
+    for (let i = 0; i < 300; i++) {
+      await adapter.create({
+        model: "user",
+        data: {
+          name: `foo${i}`,
+          email: `foo${i}@bar.com`,
+        },
+      });
+    }
+    // Better Auth defaults to a limit of 100
+    expect(
+      await adapter.findMany({
+        model: "user",
+      })
+    ).toHaveLength(100);
+
+    // Pagination has a hardcoded numItems max of 200, this tests that it can handle
+    // specified limits beyond that
+    expect(
+      await adapter.findMany({
+        model: "user",
+        limit: 250,
+      })
+    ).toHaveLength(250);
+    expect(
+      await adapter.findMany({
+        model: "user",
+        limit: 350,
+      })
+    ).toHaveLength(300);
+  });
+  test("should handle OR where clauses", async () => {
+    const adapter = await getAdapter();
+    const user = await adapter.create({
+      model: "user",
+      data: {
+        name: "foo",
+        email: "foo@bar.com",
+      },
+    });
+    expect(
+      await adapter.findOne({
+        model: "user",
+        where: [
+          { field: "name", value: "bar", connector: "OR" },
+          { field: "name", value: "foo", connector: "OR" },
+        ],
+      })
+    ).toEqual(user);
+  });
+  test("should handle OR where clauses with sortBy", async () => {
+    const adapter = await getAdapter();
+    const fooUser = await adapter.create({
+      model: "user",
+      data: {
+        name: "foo",
+        email: "foo@bar.com",
+      },
+    });
+    const barUser = await adapter.create({
+      model: "user",
+      data: {
+        name: "bar",
+        email: "bar@bar.com",
+      },
+    });
+    await adapter.create({
+      model: "user",
+      data: {
+        name: "baz",
+        email: "baz@bar.com",
+      },
+    });
+    expect(
+      await adapter.findMany({
+        model: "user",
+        where: [
+          { field: "name", value: "bar", connector: "OR" },
+          { field: "name", value: "foo", connector: "OR" },
+        ],
+        sortBy: { field: "name", direction: "asc" },
+      })
+    ).toEqual([barUser, fooUser]);
+    expect(
+      await adapter.findMany({
+        model: "user",
+        where: [
+          { field: "name", value: "bar", connector: "OR" },
+          { field: "name", value: "foo", connector: "OR" },
+        ],
+        sortBy: { field: "name", direction: "desc" },
+      })
+    ).toEqual([fooUser, barUser]);
+  });
+  test("should handle count", async () => {
+    const adapter = await getAdapter();
+    await adapter.create({
+      model: "user",
+      data: {
+        name: "foo",
+        email: "foo@bar.com",
+      },
+    });
+    await adapter.create({
+      model: "user",
+      data: {
+        name: "bar",
+        email: "bar@bar.com",
+      },
+    });
+    expect(
+      await adapter.count({
+        model: "user",
+        where: [{ field: "name", value: "foo" }],
+      })
+    ).toEqual(1);
+  });
+  test("should handle queries with no index", async () => {
+    const adapter = await getAdapter();
+    const user = await adapter.create({
+      model: "user",
+      data: {
+        name: "foo",
+        email: "foo@bar.com",
+        emailVerified: true,
+      },
+    });
+    expect(
+      await adapter.findOne({
+        model: "user",
+        where: [{ field: "emailVerified", value: true }],
+      })
+    ).toEqual(user);
+    expect(
+      await adapter.findOne({
+        model: "user",
+        where: [{ field: "emailVerified", value: false }],
+      })
+    ).toEqual(null);
+  });
+
+  test("should handle compound operator on non-unique field without an index", async () => {
+    const adapter = await getAdapter();
+    await adapter.create({
+      model: "account",
+      data: {
+        accountId: "foo",
+        providerId: "bar",
+        userId: "baz",
+        accessTokenExpiresAt: null,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      },
+    });
+    expect(
+      await adapter.findOne({
+        model: "account",
+        where: [
+          {
+            operator: "lt",
+            connector: "AND",
+            field: "accessTokenExpiresAt",
+            value: Date.now(),
+          },
+          {
+            operator: "ne",
+            connector: "AND",
+            field: "accessTokenExpiresAt",
+            value: null,
+          },
+        ],
+      })
+    ).toEqual(null);
+  });
+
+  test("should fail to create a record with a unique field that already exists", async () => {
+    const adapter = await getAdapter();
+    await adapter.create({
+      model: "user",
+      data: { name: "foo", email: "foo@bar.com" },
+    });
+    await expect(
+      adapter.create({
+        model: "user",
+        data: { name: "foo", email: "foo@bar.com" },
+      })
+    ).rejects.toThrow("user email already exists");
+  });
+
+  test("should be able to compare against a date", async () => {
+    const adapter = await getAdapter();
+    const now = new Date().toISOString();
+    const user = await adapter.create({
+      model: "user",
+      data: {
+        name: "foo",
+        email: "foo@bar.com",
+        createdAt: now,
+      },
+    });
+    expect(
+      await adapter.findOne({
+        model: "user",
+        where: [{ field: "createdAt", value: now }],
+      })
+    ).toEqual(user);
+    expect(user.createdAt).toBeInstanceOf(Date);
+  });
+}

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/schema.ts

@@ -0,0 +1,142 @@
+// This file is auto-generated. Do not edit this file manually.
+// To regenerate the schema, run:
+// `npx @better-auth/cli generate --output src/component/schema.ts -y`
+
+import { defineSchema, defineTable } from "convex/server";
+import { v } from "convex/values";
+
+export const tables = {
+  user: defineTable({
+    name: v.string(),
+    email: v.string(),
+    emailVerified: v.boolean(),
+    image: v.optional(v.union(v.null(), v.string())),
+    createdAt: v.number(),
+    updatedAt: v.number(),
+    twoFactorEnabled: v.optional(v.union(v.null(), v.boolean())),
+    isAnonymous: v.optional(v.union(v.null(), v.boolean())),
+    username: v.optional(v.union(v.null(), v.string())),
+    displayUsername: v.optional(v.union(v.null(), v.string())),
+    phoneNumber: v.optional(v.union(v.null(), v.string())),
+    phoneNumberVerified: v.optional(v.union(v.null(), v.boolean())),
+    userId: v.optional(v.union(v.null(), v.string())),
+  })
+    .index("email_name", ["email", "name"])
+    .index("name", ["name"])
+    .index("userId", ["userId"])
+    .index("username", ["username"])
+    .index("phoneNumber", ["phoneNumber"]),
+  session: defineTable({
+    expiresAt: v.number(),
+    token: v.string(),
+    createdAt: v.number(),
+    updatedAt: v.number(),
+    ipAddress: v.optional(v.union(v.null(), v.string())),
+    userAgent: v.optional(v.union(v.null(), v.string())),
+    userId: v.string(),
+  })
+    .index("expiresAt", ["expiresAt"])
+    .index("expiresAt_userId", ["expiresAt", "userId"])
+    .index("token", ["token"])
+    .index("userId", ["userId"]),
+  account: defineTable({
+    accountId: v.string(),
+    providerId: v.string(),
+    userId: v.string(),
+    accessToken: v.optional(v.union(v.null(), v.string())),
+    refreshToken: v.optional(v.union(v.null(), v.string())),
+    idToken: v.optional(v.union(v.null(), v.string())),
+    accessTokenExpiresAt: v.optional(v.union(v.null(), v.number())),
+    refreshTokenExpiresAt: v.optional(v.union(v.null(), v.number())),
+    scope: v.optional(v.union(v.null(), v.string())),
+    password: v.optional(v.union(v.null(), v.string())),
+    createdAt: v.number(),
+    updatedAt: v.number(),
+  })
+    .index("accountId", ["accountId"])
+    .index("accountId_providerId", ["accountId", "providerId"])
+    .index("providerId_userId", ["providerId", "userId"])
+    .index("userId", ["userId"]),
+  verification: defineTable({
+    identifier: v.string(),
+    value: v.string(),
+    expiresAt: v.number(),
+    createdAt: v.number(),
+    updatedAt: v.number(),
+  })
+    .index("expiresAt", ["expiresAt"])
+    .index("identifier", ["identifier"]),
+  twoFactor: defineTable({
+    secret: v.string(),
+    backupCodes: v.string(),
+    userId: v.string(),
+  }).index("userId", ["userId"]),
+  passkey: defineTable({
+    name: v.optional(v.union(v.null(), v.string())),
+    publicKey: v.string(),
+    userId: v.string(),
+    credentialID: v.string(),
+    counter: v.number(),
+    deviceType: v.string(),
+    backedUp: v.boolean(),
+    transports: v.optional(v.union(v.null(), v.string())),
+    createdAt: v.optional(v.union(v.null(), v.number())),
+    aaguid: v.optional(v.union(v.null(), v.string())),
+  })
+    .index("credentialID", ["credentialID"])
+    .index("userId", ["userId"]),
+  oauthApplication: defineTable({
+    name: v.optional(v.union(v.null(), v.string())),
+    icon: v.optional(v.union(v.null(), v.string())),
+    metadata: v.optional(v.union(v.null(), v.string())),
+    clientId: v.optional(v.union(v.null(), v.string())),
+    clientSecret: v.optional(v.union(v.null(), v.string())),
+    redirectURLs: v.optional(v.union(v.null(), v.string())),
+    type: v.optional(v.union(v.null(), v.string())),
+    disabled: v.optional(v.union(v.null(), v.boolean())),
+    userId: v.optional(v.union(v.null(), v.string())),
+    createdAt: v.optional(v.union(v.null(), v.number())),
+    updatedAt: v.optional(v.union(v.null(), v.number())),
+  })
+    .index("clientId", ["clientId"])
+    .index("userId", ["userId"]),
+  oauthAccessToken: defineTable({
+    accessToken: v.optional(v.union(v.null(), v.string())),
+    refreshToken: v.optional(v.union(v.null(), v.string())),
+    accessTokenExpiresAt: v.optional(v.union(v.null(), v.number())),
+    refreshTokenExpiresAt: v.optional(v.union(v.null(), v.number())),
+    clientId: v.optional(v.union(v.null(), v.string())),
+    userId: v.optional(v.union(v.null(), v.string())),
+    scopes: v.optional(v.union(v.null(), v.string())),
+    createdAt: v.optional(v.union(v.null(), v.number())),
+    updatedAt: v.optional(v.union(v.null(), v.number())),
+  })
+    .index("accessToken", ["accessToken"])
+    .index("refreshToken", ["refreshToken"])
+    .index("clientId", ["clientId"])
+    .index("userId", ["userId"]),
+  oauthConsent: defineTable({
+    clientId: v.optional(v.union(v.null(), v.string())),
+    userId: v.optional(v.union(v.null(), v.string())),
+    scopes: v.optional(v.union(v.null(), v.string())),
+    createdAt: v.optional(v.union(v.null(), v.number())),
+    updatedAt: v.optional(v.union(v.null(), v.number())),
+    consentGiven: v.optional(v.union(v.null(), v.boolean())),
+  })
+    .index("clientId_userId", ["clientId", "userId"])
+    .index("userId", ["userId"]),
+  jwks: defineTable({
+    publicKey: v.string(),
+    privateKey: v.string(),
+    createdAt: v.number(),
+  }),
+  rateLimit: defineTable({
+    key: v.optional(v.union(v.null(), v.string())),
+    count: v.optional(v.union(v.null(), v.number())),
+    lastRequest: v.optional(v.union(v.null(), v.number())),
+  }).index("key", ["key"]),
+};
+
+const schema = defineSchema(tables);
+
+export default schema;

package/src/nextjs/client.tsx

@@ -0,0 +1,54 @@
+import { useConvexAuth, useQuery } from "convex/react";
+import type { Preloaded } from "convex/react";
+import { makeFunctionReference } from "convex/server";
+import type { FunctionReference } from "convex/server";
+import { jsonToConvex } from "convex/values";
+import { useEffect, useMemo, useState } from "react";
+
+const useConvexPreloadedQuery = <Query extends FunctionReference<"query">>(
+  preloadedQuery: Preloaded<Query>,
+  { requireAuth = true }: { requireAuth?: boolean } = {}
+): Query["_returnType"] => {
+  const { isLoading, isAuthenticated } = useConvexAuth();
+  const [preloadExpired, setPreloadExpired] = useState(false);
+  useEffect(() => {
+    if (requireAuth && !isLoading && !isAuthenticated) {
+      setPreloadExpired(true);
+    }
+  }, [requireAuth, isLoading, isAuthenticated]);
+  const args = useMemo(
+    () => jsonToConvex(preloadedQuery._argsJSON),
+    [preloadedQuery._argsJSON]
+  ) as Query["_args"];
+  const preloadedResult = useMemo(
+    () => jsonToConvex(preloadedQuery._valueJSON),
+    [preloadedQuery._valueJSON]
+  );
+  const result = useQuery(
+    makeFunctionReference(preloadedQuery._name) as Query,
+    requireAuth && !isAuthenticated ? ("skip" as const) : args
+  );
+  useEffect(() => {
+    if (result !== undefined) {
+      setPreloadExpired(true);
+    }
+  }, [result]);
+  if (requireAuth) {
+    return preloadExpired ? result : preloadedResult;
+  }
+  return result === undefined ? preloadedResult : result;
+};
+
+export const usePreloadedAuthQuery = <Query extends FunctionReference<"query">>(
+  preloadedQuery: Preloaded<Query>
+): Query["_returnType"] | null => {
+  const { isLoading } = useConvexAuth();
+  const latestData = useConvexPreloadedQuery(preloadedQuery);
+  const [data, setData] = useState(latestData);
+  useEffect(() => {
+    if (!isLoading) {
+      setData(latestData);
+    }
+  }, [latestData, isLoading]);
+  return data;
+};