@auth/fauna-adapter 1.3.3 → 2.1.0

package/index.d.ts

@@ -9,58 +9,40 @@
  * ## Installation
  *
  * ```bash npm2yarn
- * npm install @auth/fauna-adapter faunadb
+ * npm install @auth/fauna-adapter fauna
  * ```
  *
  * @module @auth/fauna-adapter
  */
-import { Client as FaunaClient, ExprArg } from "faunadb";
-import { Adapter } from "@auth/core/adapters";
-export declare const collections: {
-    readonly Users: import("faunadb").Expr;
-    readonly Accounts: import("faunadb").Expr;
-    readonly Sessions: import("faunadb").Expr;
-    readonly VerificationTokens: import("faunadb").Expr;
+import { Client, TimeStub, QueryValue, QueryValueObject } from "fauna";
+import type { Adapter, AdapterUser, AdapterSession, VerificationToken, AdapterAccount } from "@auth/core/adapters";
+type ToFauna<T> = {
+    [P in keyof T]: T[P] extends Date | null ? TimeStub | null : T[P] extends undefined ? null : T[P] extends QueryValue ? T[P] : QueryValueObject;
 };
-export declare const indexes: {
-    readonly AccountByProviderAndProviderAccountId: import("faunadb").Expr;
-    readonly UserByEmail: import("faunadb").Expr;
-    readonly SessionByToken: import("faunadb").Expr;
-    readonly VerificationTokenByIdentifierAndToken: import("faunadb").Expr;
-    readonly SessionsByUser: import("faunadb").Expr;
-    readonly AccountsByUser: import("faunadb").Expr;
-};
-export declare const format: {
-    /** Takes a plain old JavaScript object and turns it into a Fauna object */
-    to(object: Record<string, any>): Record<string, unknown>;
-    /** Takes a Fauna object and returns a plain old JavaScript object */
-    from<T = Record<string, unknown>>(object: Record<string, any>): T;
+export type FaunaUser = ToFauna<AdapterUser>;
+export type FaunaSession = ToFauna<AdapterSession>;
+export type FaunaVerificationToken = ToFauna<VerificationToken> & {
+    id: string;
 };
-/**
- * Fauna throws an error when something is not found in the db,
- * `next-auth` expects `null` to be returned
- */
-export declare function query(f: FaunaClient, format: (...args: any) => any): <T>(expr: ExprArg) => Promise<T | null>;
+export type FaunaAccount = ToFauna<AdapterAccount>;
 /**
  *
  * ## Setup
  *
- * This is the Fauna Adapter for [`next-auth`](https://authjs.dev). This package can only be used in conjunction with the primary `next-auth` package. It is not a standalone package.
+ * This is the Fauna Adapter for [Auth.js](https://authjs.dev). This package can only be used in conjunction with the primary `next-auth` and other framework packages. It is not a standalone package.
  *
- * You can find the Fauna schema and seed information in the docs at [authjs.dev/reference/core/adapters/fauna](https://authjs.dev/reference/core/adapters/fauna).
+ * You can find the Fauna schema and seed information in the docs at [authjs.dev/reference/adapter/fauna](https://authjs.dev/reference/adapter/fauna).
  *
  * ### Configure Auth.js
  *
  * ```javascript title="pages/api/auth/[...nextauth].js"
  * import NextAuth from "next-auth"
- * import { Client as FaunaClient } from "faunadb"
+ * import { Client } from "fauna"
  * import { FaunaAdapter } from "@auth/fauna-adapter"
  *
- * const client = new FaunaClient({
+ * const client = new Client({
  *   secret: "secret",
- *   scheme: "http",
- *   domain: "localhost",
- *   port: 8443,
+ *   endpoint: new URL('http://localhost:8443')
  * })
  *
  * // For more information on each option (and a full list of options) go to
@@ -75,46 +57,138 @@ export declare function query(f: FaunaClient, format: (...args: any) => any): <T
  *
  * ### Schema
  *
- * Run the following commands inside of the `Shell` tab in the Fauna dashboard to setup the appropriate collections and indexes.
+ * Run the following FQL code inside the `Shell` tab in the Fauna dashboard to set up the appropriate collections and indexes.
  *
  * ```javascript
- * CreateCollection({ name: "accounts" })
- * CreateCollection({ name: "sessions" })
- * CreateCollection({ name: "users" })
- * CreateCollection({ name: "verification_tokens" })
+ * Collection.create({
+ *   name: "Account",
+ *   indexes: {
+ *     byUserId: {
+ *       terms: [
+ *         { field: "userId" }
+ *       ]
+ *     },
+ *     byProviderAndProviderAccountId: {
+ *       terms [
+ *         { field: "provider" },
+ *         { field: "providerAccountId" }
+ *       ]
+ *     },
+ *   }
+ * })
+ * Collection.create({
+ *   name: "Session",
+ *   constraints: [
+ *     {
+ *       unique: ["sessionToken"],
+ *       status: "active",
+ *     }
+ *   ],
+ *   indexes: {
+ *     bySessionToken: {
+ *       terms: [
+ *         { field: "sessionToken" }
+ *       ]
+ *     },
+ *     byUserId: {
+ *       terms [
+ *         { field: "userId" }
+ *       ]
+ *     },
+ *   }
+ * })
+ * Collection.create({
+ *   name: "User",
+ *   constraints: [
+ *     {
+ *       unique: ["email"],
+ *       status: "active",
+ *     }
+ *   ],
+ *   indexes: {
+ *     byEmail: {
+ *       terms [
+ *         { field: "email" }
+ *       ]
+ *     },
+ *   }
+ * })
+ * Collection.create({
+ *   name: "VerificationToken",
+ *   indexes: {
+ *     byIdentifierAndToken: {
+ *       terms [
+ *         { field: "identifier" },
+ *         { field: "token" }
+ *       ]
+ *     },
+ *   }
+ * })
  * ```
  *
+ * > This schema is adapted for use in Fauna and based upon our main [schema](https://authjs.dev/reference/core/adapters#models)
+ *
+ * ### Migrating from v1
+ * In v2, we've renamed the collections to use uppercase naming, in accordance with Fauna best practices. If you're migrating from v1, you'll need to rename your collections to match the new naming scheme.
+ * Additionally, we've renamed the indexes to match the new method-like index names.
+ *
+ * #### Migration script
+ * Run this FQL script inside a Fauna shell for the database you're migrating from v1 to v2 (it will rename your collections and indexes to match):
+ *
  * ```javascript
- * CreateIndex({
- *   name: "account_by_provider_and_provider_account_id",
- *   source: Collection("accounts"),
- *   unique: true,
- *   terms: [
- *     { field: ["data", "provider"] },
- *     { field: ["data", "providerAccountId"] },
- *   ],
+ * Collection.byName("accounts")!.update({
+ *   name: "Account"
+ *   indexes: {
+ *     byUserId: {
+ *         terms: [{ field: "userId" }]
+ *     },
+ *     byProviderAndProviderAccountId: {
+ *         terms: [{ field: "provider" }, { field: "providerAccountId" }]
+ *     },
+ *     account_by_provider_and_provider_account_id: null,
+ *     accounts_by_user_id: null
+ *   }
  * })
- * CreateIndex({
- *   name: "session_by_session_token",
- *   source: Collection("sessions"),
- *   unique: true,
- *   terms: [{ field: ["data", "sessionToken"] }],
+ * Collection.byName("sessions")!.update({
+ *   name: "Session",
+ *   indexes: {
+ *     bySessionToken: {
+ *         terms: [{ field: "sessionToken" }]
+ *     },
+ *     byUserId: {
+ *         terms: [{ field: "userId" }]
+ *     },
+ *     session_by_session_token: null,
+ *     sessions_by_user_id: null
+ *   }
  * })
- * CreateIndex({
- *   name: "user_by_email",
- *   source: Collection("users"),
- *   unique: true,
- *   terms: [{ field: ["data", "email"] }],
+ * Collection.byName("users")!.update({
+ *   name: "User",
+ *   indexes: {
+ *     byEmail: {
+ *         terms: [{ field: "email" }]
+ *     },
+ *     user_by_email: null
+ *   }
  * })
- * CreateIndex({
- *   name: "verification_token_by_identifier_and_token",
- *   source: Collection("verification_tokens"),
- *   unique: true,
- *   terms: [{ field: ["data", "identifier"] }, { field: ["data", "token"] }],
+ * Collection.byName("verification_tokens")!.update({
+ *   name: "VerificationToken",
+ *   indexes: {
+ *     byIdentifierAndToken: {
+ *         terms: [{ field: "identifier" }, { field: "token" }]
+ *     },
+ *     verification_token_by_identifier_and_token: null
+ *   }
  * })
  * ```
  *
- * > This schema is adapted for use in Fauna and based upon our main [schema](https://authjs.dev/reference/core/adapters#models)
  **/
-export declare function FaunaAdapter(f: FaunaClient): Adapter;
+export declare function FaunaAdapter(client: Client): Adapter;
+export declare const format: {
+    /** Takes an object that's coming from the database and converts it to plain JavaScript. */
+    from<T>(object?: Record<string, any>): T;
+    /** Takes an object that's coming from Auth.js and prepares it to be written to the database. */
+    to<T_1>(object: Record<string, any>): T_1;
+};
+export {};
 //# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["src/index.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EACL,MAAM,IAAI,WAAW,EACrB,OAAO,EAoBR,MAAM,SAAS,CAAA;AAEhB,OAAO,EACL,OAAO,EAIR,MAAM,qBAAqB,CAAA;AAE5B,eAAO,MAAM,WAAW;;;;;CAKd,CAAA;AAEV,eAAO,MAAM,OAAO;;;;;;;CAWV,CAAA;AAEV,eAAO,MAAM,MAAM;IACjB,2EAA2E;eAChE,OAAO,MAAM,EAAE,GAAG,CAAC;IAY9B,qEAAqE;8CAC3B,OAAO,MAAM,EAAE,GAAG,CAAC;CAY9D,CAAA;AAED;;;GAGG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,aACjC,OAAO,uBAsBxC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA0EI;AACJ,wBAAgB,YAAY,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO,CAmGpD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAqB,UAAU,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAA;AAEzF,OAAO,KAAK,EACV,OAAO,EACP,WAAW,EACX,cAAc,EACd,iBAAiB,EACjB,cAAc,EACf,MAAM,qBAAqB,CAAA;AAE5B,KAAK,OAAO,CAAC,CAAC,IAAI;KACf,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,QAAQ,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,SAAS,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,UAAU,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,gBAAgB;CAC/I,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC,CAAA;AAC5C,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,cAAc,CAAC,CAAA;AAClD,MAAM,MAAM,sBAAsB,GAAG,OAAO,CAAC,iBAAiB,CAAC,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAA;AAChF,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,cAAc,CAAC,CAAA;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA6JI;AACJ,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CA4HpD;AAED,eAAO,MAAM,MAAM;IACjB,2FAA2F;qBAC3E,OAAO,MAAM,EAAE,GAAG,CAAC;IASnC,gGAAgG;oBAClF,OAAO,MAAM,EAAE,GAAG,CAAC;CAUlC,CAAA"}

package/index.js

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
 /**
  * <div style={{display: "flex", justifyContent: "space-between", alignItems: "center", padding: 16}}>
  *  <p style={{fontWeight: "normal"}}>Official <a href="https://docs.fauna.com/fauna/current/">Fauna</a> adapter for Auth.js / NextAuth.js.</p>
@@ -10,99 +9,30 @@
  * ## Installation
  *
  * ```bash npm2yarn
- * npm install @auth/fauna-adapter faunadb
+ * npm install @auth/fauna-adapter fauna
  * ```
  *
  * @module @auth/fauna-adapter
  */
-import { Collection, Create, Delete, Exists, Get, If, Index, Let, Match, Ref, Select, Time, Update, Var, Paginate, Lambda, Do, Foreach, } from "faunadb";
-export const collections = {
-    Users: Collection("users"),
-    Accounts: Collection("accounts"),
-    Sessions: Collection("sessions"),
-    VerificationTokens: Collection("verification_tokens"),
-};
-export const indexes = {
-    AccountByProviderAndProviderAccountId: Index("account_by_provider_and_provider_account_id"),
-    UserByEmail: Index("user_by_email"),
-    SessionByToken: Index("session_by_session_token"),
-    VerificationTokenByIdentifierAndToken: Index("verification_token_by_identifier_and_token"),
-    SessionsByUser: Index("sessions_by_user_id"),
-    AccountsByUser: Index("accounts_by_user_id"),
-};
-export const format = {
-    /** Takes a plain old JavaScript object and turns it into a Fauna object */
-    to(object) {
-        const newObject = {};
-        for (const key in object) {
-            const value = object[key];
-            if (value instanceof Date) {
-                newObject[key] = Time(value.toISOString());
-            }
-            else {
-                newObject[key] = value;
-            }
-        }
-        return newObject;
-    },
-    /** Takes a Fauna object and returns a plain old JavaScript object */
-    from(object) {
-        const newObject = {};
-        for (const key in object) {
-            const value = object[key];
-            if (value?.value && typeof value.value === "string") {
-                newObject[key] = new Date(value.value);
-            }
-            else {
-                newObject[key] = value;
-            }
-        }
-        return newObject;
-    },
-};
-/**
- * Fauna throws an error when something is not found in the db,
- * `next-auth` expects `null` to be returned
- */
-export function query(f, format) {
-    return async function (expr) {
-        try {
-            const result = await f.query(expr);
-            if (!result)
-                return null;
-            return format({ ...result.data, id: result.ref.id });
-        }
-        catch (error) {
-            if (error.name === "NotFound")
-                return null;
-            if (error.description?.includes("Number or numeric String expected"))
-                return null;
-            if (process.env.NODE_ENV === "test")
-                console.error(error);
-            throw error;
-        }
-    };
-}
+import { TimeStub, fql, NullDocument } from "fauna";
 /**
  *
  * ## Setup
  *
- * This is the Fauna Adapter for [`next-auth`](https://authjs.dev). This package can only be used in conjunction with the primary `next-auth` package. It is not a standalone package.
+ * This is the Fauna Adapter for [Auth.js](https://authjs.dev). This package can only be used in conjunction with the primary `next-auth` and other framework packages. It is not a standalone package.
  *
- * You can find the Fauna schema and seed information in the docs at [authjs.dev/reference/core/adapters/fauna](https://authjs.dev/reference/core/adapters/fauna).
+ * You can find the Fauna schema and seed information in the docs at [authjs.dev/reference/adapter/fauna](https://authjs.dev/reference/adapter/fauna).
  *
  * ### Configure Auth.js
  *
  * ```javascript title="pages/api/auth/[...nextauth].js"
  * import NextAuth from "next-auth"
- * import { Client as FaunaClient } from "faunadb"
+ * import { Client } from "fauna"
  * import { FaunaAdapter } from "@auth/fauna-adapter"
  *
- * const client = new FaunaClient({
+ * const client = new Client({
  *   secret: "secret",
- *   scheme: "http",
- *   domain: "localhost",
- *   port: 8443,
+ *   endpoint: new URL('http://localhost:8443')
  * })
  *
  * // For more information on each option (and a full list of options) go to
@@ -117,102 +47,258 @@ export function query(f, format) {
  *
  * ### Schema
  *
- * Run the following commands inside of the `Shell` tab in the Fauna dashboard to setup the appropriate collections and indexes.
+ * Run the following FQL code inside the `Shell` tab in the Fauna dashboard to set up the appropriate collections and indexes.
  *
  * ```javascript
- * CreateCollection({ name: "accounts" })
- * CreateCollection({ name: "sessions" })
- * CreateCollection({ name: "users" })
- * CreateCollection({ name: "verification_tokens" })
+ * Collection.create({
+ *   name: "Account",
+ *   indexes: {
+ *     byUserId: {
+ *       terms: [
+ *         { field: "userId" }
+ *       ]
+ *     },
+ *     byProviderAndProviderAccountId: {
+ *       terms [
+ *         { field: "provider" },
+ *         { field: "providerAccountId" }
+ *       ]
+ *     },
+ *   }
+ * })
+ * Collection.create({
+ *   name: "Session",
+ *   constraints: [
+ *     {
+ *       unique: ["sessionToken"],
+ *       status: "active",
+ *     }
+ *   ],
+ *   indexes: {
+ *     bySessionToken: {
+ *       terms: [
+ *         { field: "sessionToken" }
+ *       ]
+ *     },
+ *     byUserId: {
+ *       terms [
+ *         { field: "userId" }
+ *       ]
+ *     },
+ *   }
+ * })
+ * Collection.create({
+ *   name: "User",
+ *   constraints: [
+ *     {
+ *       unique: ["email"],
+ *       status: "active",
+ *     }
+ *   ],
+ *   indexes: {
+ *     byEmail: {
+ *       terms [
+ *         { field: "email" }
+ *       ]
+ *     },
+ *   }
+ * })
+ * Collection.create({
+ *   name: "VerificationToken",
+ *   indexes: {
+ *     byIdentifierAndToken: {
+ *       terms [
+ *         { field: "identifier" },
+ *         { field: "token" }
+ *       ]
+ *     },
+ *   }
+ * })
  * ```
  *
+ * > This schema is adapted for use in Fauna and based upon our main [schema](https://authjs.dev/reference/core/adapters#models)
+ *
+ * ### Migrating from v1
+ * In v2, we've renamed the collections to use uppercase naming, in accordance with Fauna best practices. If you're migrating from v1, you'll need to rename your collections to match the new naming scheme.
+ * Additionally, we've renamed the indexes to match the new method-like index names.
+ *
+ * #### Migration script
+ * Run this FQL script inside a Fauna shell for the database you're migrating from v1 to v2 (it will rename your collections and indexes to match):
+ *
  * ```javascript
- * CreateIndex({
- *   name: "account_by_provider_and_provider_account_id",
- *   source: Collection("accounts"),
- *   unique: true,
- *   terms: [
- *     { field: ["data", "provider"] },
- *     { field: ["data", "providerAccountId"] },
- *   ],
+ * Collection.byName("accounts")!.update({
+ *   name: "Account"
+ *   indexes: {
+ *     byUserId: {
+ *         terms: [{ field: "userId" }]
+ *     },
+ *     byProviderAndProviderAccountId: {
+ *         terms: [{ field: "provider" }, { field: "providerAccountId" }]
+ *     },
+ *     account_by_provider_and_provider_account_id: null,
+ *     accounts_by_user_id: null
+ *   }
  * })
- * CreateIndex({
- *   name: "session_by_session_token",
- *   source: Collection("sessions"),
- *   unique: true,
- *   terms: [{ field: ["data", "sessionToken"] }],
+ * Collection.byName("sessions")!.update({
+ *   name: "Session",
+ *   indexes: {
+ *     bySessionToken: {
+ *         terms: [{ field: "sessionToken" }]
+ *     },
+ *     byUserId: {
+ *         terms: [{ field: "userId" }]
+ *     },
+ *     session_by_session_token: null,
+ *     sessions_by_user_id: null
+ *   }
  * })
- * CreateIndex({
- *   name: "user_by_email",
- *   source: Collection("users"),
- *   unique: true,
- *   terms: [{ field: ["data", "email"] }],
+ * Collection.byName("users")!.update({
+ *   name: "User",
+ *   indexes: {
+ *     byEmail: {
+ *         terms: [{ field: "email" }]
+ *     },
+ *     user_by_email: null
+ *   }
  * })
- * CreateIndex({
- *   name: "verification_token_by_identifier_and_token",
- *   source: Collection("verification_tokens"),
- *   unique: true,
- *   terms: [{ field: ["data", "identifier"] }, { field: ["data", "token"] }],
+ * Collection.byName("verification_tokens")!.update({
+ *   name: "VerificationToken",
+ *   indexes: {
+ *     byIdentifierAndToken: {
+ *         terms: [{ field: "identifier" }, { field: "token" }]
+ *     },
+ *     verification_token_by_identifier_and_token: null
+ *   }
  * })
  * ```
  *
- * > This schema is adapted for use in Fauna and based upon our main [schema](https://authjs.dev/reference/core/adapters#models)
  **/
-export function FaunaAdapter(f) {
-    const { Users, Accounts, Sessions, VerificationTokens } = collections;
-    const { AccountByProviderAndProviderAccountId, AccountsByUser, SessionByToken, SessionsByUser, UserByEmail, VerificationTokenByIdentifierAndToken, } = indexes;
-    const { to, from } = format;
-    const q = query(f, from);
+export function FaunaAdapter(client) {
     return {
-        createUser: async (data) => (await q(Create(Users, { data: to(data) }))),
-        getUser: async (id) => await q(Get(Ref(Users, id))),
-        getUserByEmail: async (email) => await q(Get(Match(UserByEmail, email))),
+        async createUser(user) {
+            const response = await client.query(fql `User.create(${format.to(user)})`);
+            return format.from(response.data);
+        },
+        async getUser(id) {
+            const response = await client.query(fql `User.byId(${id})`);
+            if (response.data instanceof NullDocument)
+                return null;
+            return format.from(response.data);
+        },
+        async getUserByEmail(email) {
+            const response = await client.query(fql `User.byEmail(${email}).first()`);
+            if (response.data === null)
+                return null;
+            return format.from(response.data);
+        },
         async getUserByAccount({ provider, providerAccountId }) {
-            const key = [provider, providerAccountId];
-            const ref = Match(AccountByProviderAndProviderAccountId, key);
-            const user = await q(Let({ ref }, If(Exists(Var("ref")), Get(Ref(Users, Select(["data", "userId"], Get(Var("ref"))))), null)));
-            return user;
+            const response = await client.query(fql `
+        let account = Account.byProviderAndProviderAccountId(${provider}, ${providerAccountId}).first()
+        if (account != null) {
+          User.byId(account.userId)
+        } else {
+          null
+        }
+      `);
+            return format.from(response.data);
+        },
+        async updateUser(user) {
+            const _user = { ...user };
+            delete _user.id;
+            const response = await client.query(fql `User.byId(${user.id}).update(${format.to(_user)})`);
+            return format.from(response.data);
         },
-        updateUser: async (data) => (await q(Update(Ref(Users, data.id), { data: to(data) }))),
         async deleteUser(userId) {
-            await f.query(Do(Foreach(Paginate(Match(SessionsByUser, userId)), Lambda("ref", Delete(Var("ref")))), Foreach(Paginate(Match(AccountsByUser, userId)), Lambda("ref", Delete(Var("ref")))), Delete(Ref(Users, userId))));
+            await client.query(fql `
+        // Delete the user's sessions
+        Session.byUserId(${userId}).forEach(session => session.delete())
+        
+        // Delete the user's accounts
+        Account.byUserId(${userId}).forEach(account => account.delete())
+        
+        // Delete the user
+        User.byId(${userId}).delete()
+      `);
+        },
+        async linkAccount(account) {
+            await client.query(fql `Account.create(${format.to(account)})`);
+            return account;
         },
-        linkAccount: async (data) => (await q(Create(Accounts, { data: to(data) }))),
         async unlinkAccount({ provider, providerAccountId }) {
-            const id = [provider, providerAccountId];
-            await q(Delete(Select("ref", Get(Match(AccountByProviderAndProviderAccountId, id)))));
+            const response = await client.query(fql `Account.byProviderAndProviderAccountId(${provider}, ${providerAccountId}).first().delete()`);
+            return format.from(response.data);
         },
-        createSession: async (data) => (await q(Create(Sessions, { data: to(data) }))),
         async getSessionAndUser(sessionToken) {
-            const session = await q(Get(Match(SessionByToken, sessionToken)));
-            if (!session)
+            const response = await client.query(fql `
+        let session = Session.bySessionToken(${sessionToken}).first()
+        if (session != null) {
+          let user = User.byId(session.userId)
+          if (user != null) {
+            [user, session]
+          } else {
+            null
+          }
+        } else {
+          null
+        }
+      `);
+            if (response.data === null)
                 return null;
-            const user = await q(Get(Ref(Users, session.userId)));
-            return { session, user: user };
+            const [user, session] = response.data ?? [];
+            return { session: format.from(session), user: format.from(user) };
         },
-        async updateSession(data) {
-            const ref = Select("ref", Get(Match(SessionByToken, data.sessionToken)));
-            return await q(Update(ref, { data: to(data) }));
+        async createSession(session) {
+            await client.query(fql `Session.create(${format.to(session)})`);
+            return session;
+        },
+        async updateSession(session) {
+            const response = await client.query(fql `Session.bySessionToken(${session.sessionToken}).first().update(${format.to(session)})`);
+            return format.from(response.data);
         },
         async deleteSession(sessionToken) {
-            await q(Delete(Select("ref", Get(Match(SessionByToken, sessionToken)))));
+            await client.query(fql `Session.bySessionToken(${sessionToken}).first().delete()`);
         },
-        async createVerificationToken(data) {
-            // @ts-expect-error
-            const { id: _id, ...verificationToken } = await q(Create(VerificationTokens, { data: to(data) }));
+        async createVerificationToken(verificationToken) {
+            await client.query(fql `VerificationToken.create(${format.to(verificationToken)})`);
             return verificationToken;
         },
         async useVerificationToken({ identifier, token }) {
-            const key = [identifier, token];
-            const object = Get(Match(VerificationTokenByIdentifierAndToken, key));
-            const verificationToken = await q(object);
-            if (!verificationToken)
+            const response = await client.query(fql `VerificationToken.byIdentifierAndToken(${identifier}, ${token}).first()`);
+            if (response.data === null)
                 return null;
-            // Verification tokens can be used only once
-            await q(Delete(Select("ref", object)));
-            // @ts-expect-error
-            delete verificationToken.id;
-            return verificationToken;
+            // Delete the verification token so it can only be used once
+            await client.query(fql `VerificationToken.byId(${response.data.id}).delete()`);
+            const _verificationToken = { ...response.data };
+            delete _verificationToken.id;
+            return format.from(_verificationToken);
         },
     };
 }
+export const format = {
+    /** Takes an object that's coming from the database and converts it to plain JavaScript. */
+    from(object = {}) {
+        if (!object)
+            return null;
+        const newObject = {};
+        for (const [key, value] of Object.entries(object))
+            if (key === "coll" || key === "ts")
+                continue;
+            else if (value instanceof TimeStub)
+                newObject[key] = value.toDate();
+            else
+                newObject[key] = value;
+        return newObject;
+    },
+    /** Takes an object that's coming from Auth.js and prepares it to be written to the database. */
+    to(object) {
+        const newObject = {};
+        for (const [key, value] of Object.entries(object))
+            if (value instanceof Date)
+                newObject[key] = TimeStub.fromDate(value);
+            else if (typeof value === "string" && !isNaN(Date.parse(value)))
+                newObject[key] = TimeStub.from(value);
+            else
+                newObject[key] = value ?? null;
+        return newObject;
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@auth/fauna-adapter",
-  "version": "1.3.3",
+  "version": "2.1.0",
   "description": "Fauna Adapter for Auth.js",
   "homepage": "https://authjs.dev",
   "repository": "https://github.com/nextauthjs/next-auth",
@@ -10,7 +10,8 @@
   "author": "Bhanu Teja P",
   "contributors": [
     "Nico Domino <yo@ndo.dev>",
-    "Balázs Orbán <info@balazsorban.com>"
+    "Balázs Orbán <info@balazsorban.com>",
+    "Aske Hippe Brun <mail@askehippebrun.com>"
   ],
   "type": "module",
   "types": "./index.d.ts",
@@ -37,20 +38,19 @@
     "access": "public"
   },
   "dependencies": {
-    "@auth/core": "0.26.3"
+    "@auth/core": "0.28.0"
   },
   "peerDependencies": {
-    "faunadb": "^4.3.0"
+    "fauna": "^1.3.1"
   },
   "devDependencies": {
-    "@fauna-labs/fauna-schema-migrate": "^2.1.3",
-    "faunadb": "^4.3.0"
+    "fauna": "^1.3.1",
+    "fauna-shell": "1.2.1"
   },
   "scripts": {
+    "fauna": "fauna",
     "build": "tsc",
     "dev": "tsc -w",
-    "clean": "rm -rf dist",
-    "migrate": "fauna-schema-migrate generate",
     "test": "./test/test.sh"
   }
 }

package/src/index.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
 /**
  * <div style={{display: "flex", justifyContent: "space-between", alignItems: "center", padding: 16}}>
  *  <p style={{fontWeight: "normal"}}>Official <a href="https://docs.fauna.com/fauna/current/">Fauna</a> adapter for Auth.js / NextAuth.js.</p>
@@ -10,140 +9,48 @@
  * ## Installation
  *
  * ```bash npm2yarn
- * npm install @auth/fauna-adapter faunadb
+ * npm install @auth/fauna-adapter fauna
  * ```
  *
  * @module @auth/fauna-adapter
  */
-import {
-  Client as FaunaClient,
-  ExprArg,
-  Collection,
-  Create,
-  Delete,
-  Exists,
-  Get,
-  If,
-  Index,
-  Let,
-  Match,
-  Ref,
-  Select,
-  Time,
-  Update,
-  Var,
-  Paginate,
-  Lambda,
-  Do,
-  Foreach,
-  errors,
-} from "faunadb"
+import { Client, TimeStub, fql, NullDocument, QueryValue, QueryValueObject } from "fauna"
 
-import {
+import type {
   Adapter,
-  AdapterSession,
   AdapterUser,
+  AdapterSession,
   VerificationToken,
+  AdapterAccount,
 } from "@auth/core/adapters"
 
-export const collections = {
-  Users: Collection("users"),
-  Accounts: Collection("accounts"),
-  Sessions: Collection("sessions"),
-  VerificationTokens: Collection("verification_tokens"),
-} as const
-
-export const indexes = {
-  AccountByProviderAndProviderAccountId: Index(
-    "account_by_provider_and_provider_account_id"
-  ),
-  UserByEmail: Index("user_by_email"),
-  SessionByToken: Index("session_by_session_token"),
-  VerificationTokenByIdentifierAndToken: Index(
-    "verification_token_by_identifier_and_token"
-  ),
-  SessionsByUser: Index("sessions_by_user_id"),
-  AccountsByUser: Index("accounts_by_user_id"),
-} as const
-
-export const format = {
-  /** Takes a plain old JavaScript object and turns it into a Fauna object */
-  to(object: Record<string, any>) {
-    const newObject: Record<string, unknown> = {}
-    for (const key in object) {
-      const value = object[key]
-      if (value instanceof Date) {
-        newObject[key] = Time(value.toISOString())
-      } else {
-        newObject[key] = value
-      }
-    }
-    return newObject
-  },
-  /** Takes a Fauna object and returns a plain old JavaScript object */
-  from<T = Record<string, unknown>>(object: Record<string, any>): T {
-    const newObject: Record<string, unknown> = {}
-    for (const key in object) {
-      const value = object[key]
-      if (value?.value && typeof value.value === "string") {
-        newObject[key] = new Date(value.value)
-      } else {
-        newObject[key] = value
-      }
-    }
-    return newObject as T
-  },
+type ToFauna<T> = {
+  [P in keyof T]: T[P] extends Date | null ? TimeStub | null : T[P] extends undefined ? null : T[P] extends QueryValue ? T[P] : QueryValueObject
 }
 
-/**
- * Fauna throws an error when something is not found in the db,
- * `next-auth` expects `null` to be returned
- */
-export function query(f: FaunaClient, format: (...args: any) => any) {
-  return async function <T>(expr: ExprArg): Promise<T | null> {
-    try {
-      const result = await f.query<{
-        data: T
-        ref: { id: string }
-      } | null>(expr)
-      if (!result) return null
-      return format({ ...result.data, id: result.ref.id })
-    } catch (error) {
-      if ((error as errors.FaunaError).name === "NotFound") return null
-      if (
-        (error as errors.FaunaError).description?.includes(
-          "Number or numeric String expected"
-        )
-      )
-        return null
-
-      if (process.env.NODE_ENV === "test") console.error(error)
-
-      throw error
-    }
-  }
-}
+export type FaunaUser = ToFauna<AdapterUser>
+export type FaunaSession = ToFauna<AdapterSession>
+export type FaunaVerificationToken = ToFauna<VerificationToken> & { id: string }
+export type FaunaAccount = ToFauna<AdapterAccount>
 
 /**
  *
  * ## Setup
  *
- * This is the Fauna Adapter for [`next-auth`](https://authjs.dev). This package can only be used in conjunction with the primary `next-auth` package. It is not a standalone package.
+ * This is the Fauna Adapter for [Auth.js](https://authjs.dev). This package can only be used in conjunction with the primary `next-auth` and other framework packages. It is not a standalone package.
  *
- * You can find the Fauna schema and seed information in the docs at [authjs.dev/reference/core/adapters/fauna](https://authjs.dev/reference/core/adapters/fauna).
+ * You can find the Fauna schema and seed information in the docs at [authjs.dev/reference/adapter/fauna](https://authjs.dev/reference/adapter/fauna).
  *
  * ### Configure Auth.js
  *
  * ```javascript title="pages/api/auth/[...nextauth].js"
  * import NextAuth from "next-auth"
- * import { Client as FaunaClient } from "faunadb"
+ * import { Client } from "fauna"
  * import { FaunaAdapter } from "@auth/fauna-adapter"
  *
- * const client = new FaunaClient({
+ * const client = new Client({
  *   secret: "secret",
- *   scheme: "http",
- *   domain: "localhost",
- *   port: 8443,
+ *   endpoint: new URL('http://localhost:8443')
  * })
  *
  * // For more information on each option (and a full list of options) go to
@@ -158,144 +65,278 @@ export function query(f: FaunaClient, format: (...args: any) => any) {
  *
  * ### Schema
  *
- * Run the following commands inside of the `Shell` tab in the Fauna dashboard to setup the appropriate collections and indexes.
+ * Run the following FQL code inside the `Shell` tab in the Fauna dashboard to set up the appropriate collections and indexes.
  *
  * ```javascript
- * CreateCollection({ name: "accounts" })
- * CreateCollection({ name: "sessions" })
- * CreateCollection({ name: "users" })
- * CreateCollection({ name: "verification_tokens" })
+ * Collection.create({
+ *   name: "Account",
+ *   indexes: {
+ *     byUserId: {
+ *       terms: [
+ *         { field: "userId" }
+ *       ]
+ *     },
+ *     byProviderAndProviderAccountId: {
+ *       terms [
+ *         { field: "provider" },
+ *         { field: "providerAccountId" }
+ *       ]
+ *     },
+ *   }
+ * })
+ * Collection.create({
+ *   name: "Session",
+ *   constraints: [
+ *     {
+ *       unique: ["sessionToken"],
+ *       status: "active",
+ *     }
+ *   ],
+ *   indexes: {
+ *     bySessionToken: {
+ *       terms: [
+ *         { field: "sessionToken" }
+ *       ]
+ *     },
+ *     byUserId: {
+ *       terms [
+ *         { field: "userId" }
+ *       ]
+ *     },
+ *   }
+ * })
+ * Collection.create({
+ *   name: "User",
+ *   constraints: [
+ *     {
+ *       unique: ["email"],
+ *       status: "active",
+ *     }
+ *   ],
+ *   indexes: {
+ *     byEmail: {
+ *       terms [
+ *         { field: "email" }
+ *       ]
+ *     },
+ *   }
+ * })
+ * Collection.create({
+ *   name: "VerificationToken",
+ *   indexes: {
+ *     byIdentifierAndToken: {
+ *       terms [
+ *         { field: "identifier" },
+ *         { field: "token" }
+ *       ]
+ *     },
+ *   }
+ * })
  * ```
  *
+ * > This schema is adapted for use in Fauna and based upon our main [schema](https://authjs.dev/reference/core/adapters#models)
+ *
+ * ### Migrating from v1
+ * In v2, we've renamed the collections to use uppercase naming, in accordance with Fauna best practices. If you're migrating from v1, you'll need to rename your collections to match the new naming scheme.
+ * Additionally, we've renamed the indexes to match the new method-like index names.
+ *
+ * #### Migration script
+ * Run this FQL script inside a Fauna shell for the database you're migrating from v1 to v2 (it will rename your collections and indexes to match):
+ *
  * ```javascript
- * CreateIndex({
- *   name: "account_by_provider_and_provider_account_id",
- *   source: Collection("accounts"),
- *   unique: true,
- *   terms: [
- *     { field: ["data", "provider"] },
- *     { field: ["data", "providerAccountId"] },
- *   ],
+ * Collection.byName("accounts")!.update({
+ *   name: "Account"
+ *   indexes: {
+ *     byUserId: {
+ *         terms: [{ field: "userId" }]
+ *     },
+ *     byProviderAndProviderAccountId: {
+ *         terms: [{ field: "provider" }, { field: "providerAccountId" }]
+ *     },
+ *     account_by_provider_and_provider_account_id: null,
+ *     accounts_by_user_id: null
+ *   }
  * })
- * CreateIndex({
- *   name: "session_by_session_token",
- *   source: Collection("sessions"),
- *   unique: true,
- *   terms: [{ field: ["data", "sessionToken"] }],
+ * Collection.byName("sessions")!.update({
+ *   name: "Session",
+ *   indexes: {
+ *     bySessionToken: {
+ *         terms: [{ field: "sessionToken" }]
+ *     },
+ *     byUserId: {
+ *         terms: [{ field: "userId" }]
+ *     },
+ *     session_by_session_token: null,
+ *     sessions_by_user_id: null
+ *   }
  * })
- * CreateIndex({
- *   name: "user_by_email",
- *   source: Collection("users"),
- *   unique: true,
- *   terms: [{ field: ["data", "email"] }],
+ * Collection.byName("users")!.update({
+ *   name: "User",
+ *   indexes: {
+ *     byEmail: {
+ *         terms: [{ field: "email" }]
+ *     },
+ *     user_by_email: null
+ *   }
  * })
- * CreateIndex({
- *   name: "verification_token_by_identifier_and_token",
- *   source: Collection("verification_tokens"),
- *   unique: true,
- *   terms: [{ field: ["data", "identifier"] }, { field: ["data", "token"] }],
+ * Collection.byName("verification_tokens")!.update({
+ *   name: "VerificationToken",
+ *   indexes: {
+ *     byIdentifierAndToken: {
+ *         terms: [{ field: "identifier" }, { field: "token" }]
+ *     },
+ *     verification_token_by_identifier_and_token: null
+ *   }
  * })
  * ```
  *
- * > This schema is adapted for use in Fauna and based upon our main [schema](https://authjs.dev/reference/core/adapters#models)
  **/
-export function FaunaAdapter(f: FaunaClient): Adapter {
-  const { Users, Accounts, Sessions, VerificationTokens } = collections
-  const {
-    AccountByProviderAndProviderAccountId,
-    AccountsByUser,
-    SessionByToken,
-    SessionsByUser,
-    UserByEmail,
-    VerificationTokenByIdentifierAndToken,
-  } = indexes
-  const { to, from } = format
-  const q = query(f, from)
+export function FaunaAdapter(client: Client): Adapter {
   return {
-    createUser: async (data) => (await q(Create(Users, { data: to(data) })))!,
-    getUser: async (id) => await q(Get(Ref(Users, id))),
-    getUserByEmail: async (email) => await q(Get(Match(UserByEmail, email))),
+    async createUser(user) {
+      const response = await client.query<FaunaUser>(
+        fql`User.create(${format.to(user)})`,
+      )
+      return format.from(response.data)
+    },
+    async getUser(id) {
+      const response = await client.query<FaunaUser | NullDocument>(
+        fql`User.byId(${id})`,
+      )
+      if (response.data instanceof NullDocument) return null
+      return format.from(response.data)
+    },
+    async getUserByEmail(email) {
+      const response = await client.query<FaunaUser>(
+        fql`User.byEmail(${email}).first()`,
+      )
+      if (response.data === null) return null
+      return format.from(response.data)
+    },
     async getUserByAccount({ provider, providerAccountId }) {
-      const key = [provider, providerAccountId]
-      const ref = Match(AccountByProviderAndProviderAccountId, key)
-      const user = await q<AdapterUser>(
-        Let(
-          { ref },
-          If(
-            Exists(Var("ref")),
-            Get(Ref(Users, Select(["data", "userId"], Get(Var("ref"))))),
-            null
-          )
-        )
+      const response = await client.query<FaunaUser>(fql`
+        let account = Account.byProviderAndProviderAccountId(${provider}, ${providerAccountId}).first()
+        if (account != null) {
+          User.byId(account.userId)
+        } else {
+          null
+        }
+      `)
+      return format.from(response.data)
+    },
+    async updateUser(user) {
+      const _user: Partial<AdapterUser> = { ...user }
+      delete _user.id
+      const response = await client.query<FaunaUser>(
+        fql`User.byId(${user.id}).update(${format.to(_user)})`,
       )
-      return user
+      return format.from(response.data)
     },
-    updateUser: async (data) =>
-      (await q(Update(Ref(Users, data.id), { data: to(data) })))!,
     async deleteUser(userId) {
-      await f.query(
-        Do(
-          Foreach(
-            Paginate(Match(SessionsByUser, userId)),
-            Lambda("ref", Delete(Var("ref")))
-          ),
-          Foreach(
-            Paginate(Match(AccountsByUser, userId)),
-            Lambda("ref", Delete(Var("ref")))
-          ),
-          Delete(Ref(Users, userId))
-        )
+      await client.query(fql`
+        // Delete the user's sessions
+        Session.byUserId(${userId}).forEach(session => session.delete())
+        
+        // Delete the user's accounts
+        Account.byUserId(${userId}).forEach(account => account.delete())
+        
+        // Delete the user
+        User.byId(${userId}).delete()
+      `)
+    },
+    async linkAccount(account) {
+      await client.query<FaunaAccount>(
+        fql`Account.create(${format.to(account)})`,
       )
+      return account
     },
-    linkAccount: async (data) =>
-      (await q(Create(Accounts, { data: to(data) })))!,
     async unlinkAccount({ provider, providerAccountId }) {
-      const id = [provider, providerAccountId]
-      await q(
-        Delete(
-          Select("ref", Get(Match(AccountByProviderAndProviderAccountId, id)))
-        )
+      const response = await client.query<FaunaAccount>(
+        fql`Account.byProviderAndProviderAccountId(${provider}, ${providerAccountId}).first().delete()`,
       )
+      return format.from<AdapterAccount>(response.data)
     },
-    createSession: async (data) =>
-      (await q<AdapterSession>(Create(Sessions, { data: to(data) })))!,
     async getSessionAndUser(sessionToken) {
-      const session = await q<AdapterSession>(
-        Get(Match(SessionByToken, sessionToken))
+      const response = await client.query<[FaunaUser, FaunaSession]>(fql`
+        let session = Session.bySessionToken(${sessionToken}).first()
+        if (session != null) {
+          let user = User.byId(session.userId)
+          if (user != null) {
+            [user, session]
+          } else {
+            null
+          }
+        } else {
+          null
+        }
+      `)
+      if (response.data === null) return null
+      const [user, session] = response.data ?? []
+      return { session: format.from(session), user: format.from(user) }
+    },
+    async createSession(session) {
+      await client.query<FaunaSession>(
+        fql`Session.create(${format.to(session)})`,
       )
-      if (!session) return null
-
-      const user = await q<AdapterUser>(Get(Ref(Users, session.userId)))
-
-      return { session, user: user! }
+      return session
     },
-    async updateSession(data) {
-      const ref = Select("ref", Get(Match(SessionByToken, data.sessionToken)))
-      return await q(Update(ref, { data: to(data) }))
+    async updateSession(session) {
+      const response = await client.query<FaunaSession>(
+        fql`Session.bySessionToken(${
+          session.sessionToken
+        }).first().update(${format.to(session)})`,
+      )
+      return format.from(response.data)
     },
     async deleteSession(sessionToken) {
-      await q(Delete(Select("ref", Get(Match(SessionByToken, sessionToken)))))
+      await client.query(
+        fql`Session.bySessionToken(${sessionToken}).first().delete()`,
+      )
     },
-    async createVerificationToken(data) {
-      // @ts-expect-error
-      const { id: _id, ...verificationToken } = await q<VerificationToken>(
-        Create(VerificationTokens, { data: to(data) })
+    async createVerificationToken(verificationToken) {
+      await client.query<FaunaVerificationToken>(
+        fql`VerificationToken.create(${format.to(
+          verificationToken,
+        )})`,
       )
       return verificationToken
     },
     async useVerificationToken({ identifier, token }) {
-      const key = [identifier, token]
-      const object = Get(Match(VerificationTokenByIdentifierAndToken, key))
-
-      const verificationToken = await q<VerificationToken>(object)
-      if (!verificationToken) return null
-
-      // Verification tokens can be used only once
-      await q(Delete(Select("ref", object)))
-
-      // @ts-expect-error
-      delete verificationToken.id
-      return verificationToken
+      const response = await client.query<FaunaVerificationToken>(
+        fql`VerificationToken.byIdentifierAndToken(${identifier}, ${token}).first()`,
+      )
+      if (response.data === null) return null
+      // Delete the verification token so it can only be used once
+      await client.query(
+        fql`VerificationToken.byId(${response.data.id}).delete()`,
+      )
+      const _verificationToken: Partial<FaunaVerificationToken> = { ...response.data }
+      delete _verificationToken.id
+      return format.from(_verificationToken)
     },
   }
 }
+
+export const format = {
+  /** Takes an object that's coming from the database and converts it to plain JavaScript. */
+  from<T>(object: Record<string, any> = {}): T {
+    if (!object) return null as unknown as T
+    const newObject: Record<string, unknown> = {}
+    for (const [key, value] of Object.entries(object))
+      if (key === "coll" || key === "ts") continue
+      else if (value instanceof TimeStub) newObject[key] = value.toDate()
+      else newObject[key] = value
+    return newObject as T
+  },
+  /** Takes an object that's coming from Auth.js and prepares it to be written to the database. */
+  to<T>(object: Record<string, any>): T {
+    const newObject: Record<string, unknown> = {}
+    for (const [key, value] of Object.entries(object))
+      if (value instanceof Date) newObject[key] = TimeStub.fromDate(value)
+      else if (typeof value === "string" && !isNaN(Date.parse(value)))
+        newObject[key] = TimeStub.from(value)
+      else newObject[key] = value ?? null
+
+    return newObject as T
+  },
+}