@robelest/convex-auth 0.0.2-preview.1 → 0.0.2-preview.2

package/src/providers/{Anonymous.ts → anonymous.ts}

@@ -1,22 +1,21 @@
 /**
- * Configure {@link Anonymous} provider given an {@link AnonymousConfig}.
+ * Configure {@link anonymous} provider given an {@link AnonymousConfig}.
  *
  * ```ts
- * import { Anonymous } from "@robelest/convex-auth/providers/Anonymous";
- * import { convexAuth } from "@robelest/convex-auth/component";
+ * import anonymous from "@robelest/convex-auth/providers/anonymous";
+ * import { Auth } from "@robelest/convex-auth/component";
  *
- * export const { auth, signIn, signOut, store } = convexAuth({
- *   providers: [Anonymous],
+ * export const { auth, signIn, signOut, store } = Auth({
+ *   providers: [anonymous],
  * });
  * ```
  *
  * @module
  */
 
-import convexCredentials from "@robelest/convex-auth/providers/ConvexCredentials";
+import credentials from "@robelest/convex-auth/providers/credentials";
 import {
   GenericActionCtxWithAuthConfig,
-  createAccount,
 } from "@robelest/convex-auth/component";
 import {
   DocumentByName,
@@ -26,12 +25,12 @@ import {
 import { Value } from "convex/values";
 
 /**
- * The available options to an {@link Anonymous} provider for Convex Auth.
+ * The available options to an {@link anonymous} provider for Convex Auth.
  */
 export interface AnonymousConfig<DataModel extends GenericDataModel> {
   /**
    * Uniquely identifies the provider, allowing to use
-   * multiple different {@link Anonymous} providers.
+   * multiple different {@link anonymous} providers.
    */
   id?: string;
   /**
@@ -62,11 +61,11 @@ export default function anonymous<DataModel extends GenericDataModel>(
   config: AnonymousConfig<DataModel> = {},
 ) {
   const provider = config.id ?? "anonymous";
-  return convexCredentials<DataModel>({
+  return credentials<DataModel>({
     id: "anonymous",
     authorize: async (params, ctx) => {
       const profile = config.profile?.(params, ctx) ?? { isAnonymous: true };
-      const { user } = await createAccount(ctx, {
+      const { user } = await ctx.auth.account.create(ctx, {
         provider,
         account: { id: crypto.randomUUID() },
         profile: profile as any,

package/src/providers/{ConvexCredentials.ts → credentials.ts}

@@ -1,16 +1,16 @@
 /**
- * Configure {@link ConvexCredentials} provider given a {@link ConvexCredentialsUserConfig}.
+ * Configure {@link credentials} provider given a {@link CredentialsUserConfig}.
  *
  * This is for a very custom authentication implementation, often you can
- * use the [`Password`](https://labs.convex.dev/auth/api_reference/providers/Password) provider instead.
+ * use the [`password`](https://labs.convex.dev/auth/api_reference/providers/password) provider instead.
  *
  * ```ts
- * import ConvexCredentials from "@robelest/convex-auth/providers/ConvexCredentials";
- * import { convexAuth } from "@robelest/convex-auth/component";
+ * import credentials from "@robelest/convex-auth/providers/credentials";
+ * import { Auth } from "@robelest/convex-auth/component";
  *
- * export const { auth, signIn, signOut, store } = convexAuth({
+ * export const { auth, signIn, signOut, store } = Auth({
  *   providers: [
- *     ConvexCredentials({
+ *     credentials({
  *       authorize: async (credentials, ctx) => {
  *         // Your custom logic here...
  *       },
@@ -31,14 +31,14 @@ import { GenericDataModel } from "convex/server";
 import { GenericId, Value } from "convex/values";
 
 /**
- * The available options to a {@link ConvexCredentials} provider for Convex Auth.
+ * The available options to a {@link credentials} provider for Convex Auth.
  */
-export interface ConvexCredentialsUserConfig<
+export interface CredentialsUserConfig<
   DataModel extends GenericDataModel = GenericDataModel,
 > {
   /**
    * Uniquely identifies the provider, allowing to use
-   * multiple different {@link ConvexCredentials} providers.
+   * multiple different {@link credentials} providers.
    */
   id?: string;
   /**
@@ -95,8 +95,8 @@ export interface ConvexCredentialsUserConfig<
  * The Credentials provider allows you to handle signing in with arbitrary credentials,
  * such as a username and password, domain, or two factor authentication or hardware device (e.g. YubiKey U2F / FIDO).
  */
-export default function convexCredentials<DataModel extends GenericDataModel>(
-  config: ConvexCredentialsUserConfig<DataModel>,
+export default function credentials<DataModel extends GenericDataModel>(
+  config: CredentialsUserConfig<DataModel>,
 ): ConvexCredentialsConfig {
   return {
     id: "credentials",

package/src/providers/{Email.ts → email.ts}

@@ -19,19 +19,19 @@ import { EmailConfig, EmailUserConfig } from "../server/types.js";
  * you can override the `authorize` method to skip the check:
  *
  * ```ts
- * import Email from "@robelest/convex-auth/providers/Email";
- * import { convexAuth } from "@robelest/convex-auth/component";
+ * import email from "@robelest/convex-auth/providers/email";
+ * import { Auth } from "@robelest/convex-auth/component";
  *
- * export const { auth, signIn, signOut, store } = convexAuth({
+ * export const { auth, signIn, signOut, store } = Auth({
  *   providers: [
- *     Email({ authorize: undefined }),
+ *     email({ authorize: undefined }),
  *   ],
  * });
  * ```
  *
  * Make sure the token has high enough entropy to be secure.
  */
-export function Email<DataModel extends GenericDataModel>(
+export default function email<DataModel extends GenericDataModel>(
   config: EmailUserConfig<DataModel> &
     Pick<EmailConfig, "sendVerificationRequest">,
 ): EmailConfig<DataModel> {

package/src/providers/{Password.ts → password.ts}

@@ -1,7 +1,7 @@
 /**
- * Configure {@link Password} provider given a {@link PasswordConfig}.
+ * Configure {@link password} provider given a {@link PasswordConfig}.
  *
- * The `Password` provider supports the following flows, determined
+ * The `password` provider supports the following flows, determined
  * by the `flow` parameter:
  *
  * - `"signUp"`: Create a new account with a password.
@@ -12,29 +12,24 @@
  *    included in params, verify an OTP.
  *
  * ```ts
- * import Password from "@robelest/convex-auth/providers/Password";
- * import { convexAuth } from "@robelest/convex-auth/component";
+ * import password from "@robelest/convex-auth/providers/password";
+ * import { Auth } from "@robelest/convex-auth/component";
  *
- * export const { auth, signIn, signOut, store } = convexAuth({
- *   providers: [Password],
+ * export const { auth, signIn, signOut, store } = Auth({
+ *   providers: [password],
  * });
  * ```
  *
  * @module
  */
 
-import convexCredentials, {
-  ConvexCredentialsUserConfig,
-} from "@robelest/convex-auth/providers/ConvexCredentials";
+import credentials, {
+  CredentialsUserConfig,
+} from "@robelest/convex-auth/providers/credentials";
 import {
   EmailConfig,
   GenericActionCtxWithAuthConfig,
   GenericDoc,
-  createAccount,
-  invalidateSessions,
-  modifyAccountCredentials,
-  retrieveAccount,
-  signInViaProvider,
 } from "@robelest/convex-auth/component";
 import {
   DocumentByName,
@@ -45,7 +40,7 @@ import { Value } from "convex/values";
 import { Scrypt } from "lucia";
 
 /**
- * The available options to a {@link Password} provider for Convex Auth.
+ * The available options to a {@link password} provider for Convex Auth.
  */
 export interface PasswordConfig<DataModel extends GenericDataModel> {
   /**
@@ -89,7 +84,7 @@ export interface PasswordConfig<DataModel extends GenericDataModel> {
    * Provide hashing and verification functions if you want to control
    * how passwords are hashed.
    */
-  crypto?: ConvexCredentialsUserConfig["crypto"];
+  crypto?: CredentialsUserConfig["crypto"];
   /**
    * An Auth.js email provider used to require verification
    * before password reset.
@@ -115,7 +110,7 @@ export default function password<DataModel extends GenericDataModel>(
   config: PasswordConfig<DataModel> = {},
 ) {
   const provider = config.id ?? "password";
-  return convexCredentials<DataModel>({
+  return credentials<DataModel>({
     id: "password",
     authorize: async (params, ctx) => {
       const flow = params.flow as string;
@@ -141,7 +136,7 @@ export default function password<DataModel extends GenericDataModel>(
         if (secret === undefined) {
           throw new Error("Missing `password` param for `signUp` flow");
         }
-        const created = await createAccount(ctx, {
+        const created = await ctx.auth.account.create(ctx, {
           provider,
           account: { id: email, secret },
           profile: profile as any,
@@ -153,7 +148,7 @@ export default function password<DataModel extends GenericDataModel>(
         if (secret === undefined) {
           throw new Error("Missing `password` param for `signIn` flow");
         }
-        const retrieved = await retrieveAccount(ctx, {
+        const retrieved = await ctx.auth.account.get(ctx, {
           provider,
           account: { id: email, secret },
         });
@@ -166,11 +161,11 @@ export default function password<DataModel extends GenericDataModel>(
         if (!config.reset) {
           throw new Error(`Password reset is not enabled for ${provider}`);
         }
-        const { account } = await retrieveAccount(ctx, {
+        const { account } = await ctx.auth.account.get(ctx, {
           provider,
           account: { id: email },
         });
-        return await signInViaProvider(ctx, config.reset, {
+        return await ctx.auth.provider.signIn(ctx, config.reset, {
           accountId: account._id,
           params,
         });
@@ -183,17 +178,17 @@ export default function password<DataModel extends GenericDataModel>(
             "Missing `newPassword` param for `reset-verification` flow",
           );
         }
-        const result = await signInViaProvider(ctx, config.reset, { params });
+        const result = await ctx.auth.provider.signIn(ctx, config.reset, { params });
         if (result === null) {
           throw new Error("Invalid code");
         }
         const { userId, sessionId } = result;
         const secret = params.newPassword as string;
-        await modifyAccountCredentials(ctx, {
+        await ctx.auth.account.updateCredentials(ctx, {
           provider,
           account: { id: email, secret },
         });
-        await invalidateSessions(ctx, { userId, except: [sessionId] });
+        await ctx.auth.session.invalidate(ctx, { userId, except: [sessionId] });
         return { userId, sessionId };
         // END
         // START: Optional, email verification during sign in
@@ -201,11 +196,11 @@ export default function password<DataModel extends GenericDataModel>(
         if (!config.verify) {
           throw new Error(`Email verification is not enabled for ${provider}`);
         }
-        const { account } = await retrieveAccount(ctx, {
+        const { account } = await ctx.auth.account.get(ctx, {
           provider,
           account: { id: email },
         });
-        return await signInViaProvider(ctx, config.verify, {
+        return await ctx.auth.provider.signIn(ctx, config.verify, {
           accountId: account._id,
           params,
         });
@@ -219,7 +214,7 @@ export default function password<DataModel extends GenericDataModel>(
       }
       // START: Optional, email verification during sign in
       if (config.verify && !account.emailVerified) {
-        return await signInViaProvider(ctx, config.verify, {
+        return await ctx.auth.provider.signIn(ctx, config.verify, {
           accountId: account._id,
           params,
         });

package/src/providers/{Phone.ts → phone.ts}

@@ -1,9 +1,9 @@
 /**
- * Configure {@link Phone} provider given a {@link PhoneUserConfig}.
+ * Configure {@link phone} provider given a {@link PhoneUserConfig}.
  *
  * Simplifies creating phone providers.
  *
- * By default checks that there is an `phone` field during token verification
+ * By default checks that there is a `phone` field during token verification
  * that matches the `phone` used during the initial `signIn` call.
  *
  * @module