@gatwech/auth 1.0.0-beta.18

package/dist/session-Dgp133Yt.mjs

@@ -0,0 +1,413 @@
+import { t as safeJSONParse } from "./json-D0TBLy4q.mjs";
+import { i as verifyJWT, n as symmetricDecodeJWT } from "./jwt-CmxZAGe2.mjs";
+import { c as setSessionCookie, f as getChunkedCookie, n as deleteSessionCookie, p as getSessionQuerySchema, s as setCookieCache } from "./cookies-cJObLwn1.mjs";
+import { c as parseSessionOutput, t as getDate, u as parseUserOutput } from "./date-Cx2yCiC4.mjs";
+import { BASE_ERROR_CODES } from "@gatwech/core/error";
+import { APIError } from "better-call";
+import { createAuthEndpoint, createAuthMiddleware } from "@gatwech/core/api";
+import * as z$1 from "zod";
+import { base64Url } from "@gatwech/utils/base64";
+import { binary } from "@gatwech/utils/binary";
+import { createHMAC } from "@gatwech/utils/hmac";
+
+//#region src/api/routes/session.ts
+const getSession = () => createAuthEndpoint("/get-session", {
+	method: "GET",
+	query: getSessionQuerySchema,
+	requireHeaders: true,
+	metadata: { openapi: {
+		description: "Get the current session",
+		responses: { "200": {
+			description: "Success",
+			content: { "application/json": { schema: {
+				type: "object",
+				properties: {
+					session: { $ref: "#/components/schemas/Session" },
+					user: { $ref: "#/components/schemas/User" }
+				},
+				required: ["session", "user"]
+			} } }
+		} }
+	} }
+}, async (ctx) => {
+	try {
+		const sessionCookieToken = await ctx.getSignedCookie(ctx.context.authCookies.sessionToken.name, ctx.context.secret);
+		if (!sessionCookieToken) return null;
+		const sessionDataCookie = getChunkedCookie(ctx, ctx.context.authCookies.sessionData.name);
+		let sessionDataPayload = null;
+		if (sessionDataCookie) {
+			const strategy = ctx.context.options.session?.cookieCache?.strategy || "compact";
+			if (strategy === "jwe") {
+				const payload = await symmetricDecodeJWT(sessionDataCookie, ctx.context.secret, "payvo-auth-session");
+				if (payload && payload.session && payload.user) sessionDataPayload = {
+					session: {
+						session: payload.session,
+						user: payload.user,
+						updatedAt: payload.updatedAt,
+						version: payload.version
+					},
+					expiresAt: payload.exp ? payload.exp * 1e3 : Date.now()
+				};
+				else {
+					const dataCookie = ctx.context.authCookies.sessionData.name;
+					ctx.setCookie(dataCookie, "", { maxAge: 0 });
+					return ctx.json(null);
+				}
+			} else if (strategy === "jwt") {
+				const payload = await verifyJWT(sessionDataCookie, ctx.context.secret);
+				if (payload && payload.session && payload.user) sessionDataPayload = {
+					session: {
+						session: payload.session,
+						user: payload.user,
+						updatedAt: payload.updatedAt,
+						version: payload.version
+					},
+					expiresAt: payload.exp ? payload.exp * 1e3 : Date.now()
+				};
+				else {
+					const dataCookie = ctx.context.authCookies.sessionData.name;
+					ctx.setCookie(dataCookie, "", { maxAge: 0 });
+					return ctx.json(null);
+				}
+			} else {
+				const parsed = safeJSONParse(binary.decode(base64Url.decode(sessionDataCookie)));
+				if (parsed) if (await createHMAC("SHA-256", "base64urlnopad").verify(ctx.context.secret, JSON.stringify({
+					...parsed.session,
+					expiresAt: parsed.expiresAt
+				}), parsed.signature)) sessionDataPayload = parsed;
+				else {
+					const dataCookie = ctx.context.authCookies.sessionData.name;
+					ctx.setCookie(dataCookie, "", { maxAge: 0 });
+					return ctx.json(null);
+				}
+			}
+		}
+		const dontRememberMe = await ctx.getSignedCookie(ctx.context.authCookies.dontRememberToken.name, ctx.context.secret);
+		/**
+		* If session data is present in the cookie, check if it should be used or refreshed
+		*/
+		if (sessionDataPayload?.session && ctx.context.options.session?.cookieCache?.enabled && !ctx.query?.disableCookieCache) {
+			const session$1 = sessionDataPayload.session;
+			const versionConfig = ctx.context.options.session?.cookieCache?.version;
+			let expectedVersion = "1";
+			if (versionConfig) {
+				if (typeof versionConfig === "string") expectedVersion = versionConfig;
+				else if (typeof versionConfig === "function") {
+					const result = versionConfig(session$1.session, session$1.user);
+					expectedVersion = result instanceof Promise ? await result : result;
+				}
+			}
+			if ((session$1.version || "1") !== expectedVersion) {
+				const dataCookie = ctx.context.authCookies.sessionData.name;
+				ctx.setCookie(dataCookie, "", { maxAge: 0 });
+			} else if (sessionDataPayload.expiresAt < Date.now() || session$1.session.expiresAt < /* @__PURE__ */ new Date()) {
+				const dataCookie = ctx.context.authCookies.sessionData.name;
+				ctx.setCookie(dataCookie, "", { maxAge: 0 });
+			} else {
+				const cookieRefreshCache = ctx.context.sessionConfig.cookieRefreshCache;
+				if (cookieRefreshCache === false) {
+					ctx.context.session = session$1;
+					return ctx.json({
+						session: session$1.session,
+						user: session$1.user
+					});
+				}
+				if (sessionDataPayload.expiresAt - Date.now() < cookieRefreshCache.updateAge * 1e3) {
+					const newExpiresAt = getDate(ctx.context.options.session?.cookieCache?.maxAge || 300, "sec");
+					const refreshedSession = {
+						session: {
+							...session$1.session,
+							expiresAt: newExpiresAt
+						},
+						user: session$1.user,
+						updatedAt: Date.now()
+					};
+					await setCookieCache(ctx, refreshedSession, false);
+					const parsedRefreshedSession = parseSessionOutput(ctx.context.options, {
+						...refreshedSession.session,
+						expiresAt: new Date(refreshedSession.session.expiresAt),
+						createdAt: new Date(refreshedSession.session.createdAt),
+						updatedAt: new Date(refreshedSession.session.updatedAt)
+					});
+					const parsedRefreshedUser = parseUserOutput(ctx.context.options, {
+						...refreshedSession.user,
+						createdAt: new Date(refreshedSession.user.createdAt),
+						updatedAt: new Date(refreshedSession.user.updatedAt)
+					});
+					ctx.context.session = {
+						session: parsedRefreshedSession,
+						user: parsedRefreshedUser
+					};
+					return ctx.json({
+						session: parsedRefreshedSession,
+						user: parsedRefreshedUser
+					});
+				}
+				const parsedSession = parseSessionOutput(ctx.context.options, {
+					...session$1.session,
+					expiresAt: new Date(session$1.session.expiresAt),
+					createdAt: new Date(session$1.session.createdAt),
+					updatedAt: new Date(session$1.session.updatedAt)
+				});
+				const parsedUser = parseUserOutput(ctx.context.options, {
+					...session$1.user,
+					createdAt: new Date(session$1.user.createdAt),
+					updatedAt: new Date(session$1.user.updatedAt)
+				});
+				ctx.context.session = {
+					session: parsedSession,
+					user: parsedUser
+				};
+				return ctx.json({
+					session: parsedSession,
+					user: parsedUser
+				});
+			}
+		}
+		const session = await ctx.context.internalAdapter.findSession(sessionCookieToken);
+		ctx.context.session = session;
+		if (!session || session.session.expiresAt < /* @__PURE__ */ new Date()) {
+			deleteSessionCookie(ctx);
+			if (session)
+ /**
+			* if session expired clean up the session
+			*/
+			await ctx.context.internalAdapter.deleteSession(session.session.token);
+			return ctx.json(null);
+		}
+		/**
+		* We don't need to update the session if the user doesn't want to be remembered
+		* or if the session refresh is disabled
+		*/
+		if (dontRememberMe || ctx.query?.disableRefresh) {
+			const parsedSession = parseSessionOutput(ctx.context.options, session.session);
+			const parsedUser = parseUserOutput(ctx.context.options, session.user);
+			return ctx.json({
+				session: parsedSession,
+				user: parsedUser
+			});
+		}
+		const expiresIn = ctx.context.sessionConfig.expiresIn;
+		const updateAge = ctx.context.sessionConfig.updateAge;
+		if (session.session.expiresAt.valueOf() - expiresIn * 1e3 + updateAge * 1e3 <= Date.now() && (!ctx.query?.disableRefresh || !ctx.context.options.session?.disableSessionRefresh)) {
+			const updatedSession = await ctx.context.internalAdapter.updateSession(session.session.token, {
+				expiresAt: getDate(ctx.context.sessionConfig.expiresIn, "sec"),
+				updatedAt: /* @__PURE__ */ new Date()
+			});
+			if (!updatedSession) {
+				/**
+				* Handle case where session update fails (e.g., concurrent deletion)
+				*/
+				deleteSessionCookie(ctx);
+				return ctx.json(null, { status: 401 });
+			}
+			const maxAge = (updatedSession.expiresAt.valueOf() - Date.now()) / 1e3;
+			await setSessionCookie(ctx, {
+				session: updatedSession,
+				user: session.user
+			}, false, { maxAge });
+			const parsedUpdatedSession = parseSessionOutput(ctx.context.options, updatedSession);
+			const parsedUser = parseUserOutput(ctx.context.options, session.user);
+			return ctx.json({
+				session: parsedUpdatedSession,
+				user: parsedUser
+			});
+		}
+		await setCookieCache(ctx, session, !!dontRememberMe);
+		return ctx.json(session);
+	} catch (error) {
+		ctx.context.logger.error("INTERNAL_SERVER_ERROR", error);
+		throw new APIError("INTERNAL_SERVER_ERROR", { message: BASE_ERROR_CODES.FAILED_TO_GET_SESSION });
+	}
+});
+const getSessionFromCtx = async (ctx, config) => {
+	if (ctx.context.session) return ctx.context.session;
+	const session = await getSession()({
+		...ctx,
+		asResponse: false,
+		headers: ctx.headers,
+		returnHeaders: false,
+		query: {
+			...config,
+			...ctx.query
+		}
+	}).catch((e) => {
+		return null;
+	});
+	ctx.context.session = session;
+	return session;
+};
+/**
+* The middleware forces the endpoint to require a valid session.
+*/
+const sessionMiddleware = createAuthMiddleware(async (ctx) => {
+	const session = await getSessionFromCtx(ctx);
+	if (!session?.session) throw new APIError("UNAUTHORIZED");
+	return { session };
+});
+/**
+* This middleware forces the endpoint to require a valid session and ignores cookie cache.
+* This should be used for sensitive operations like password changes, account deletion, etc.
+* to ensure that revoked sessions cannot be used even if they're still cached in cookies.
+*/
+const sensitiveSessionMiddleware = createAuthMiddleware(async (ctx) => {
+	const session = await getSessionFromCtx(ctx, { disableCookieCache: true });
+	if (!session?.session) throw new APIError("UNAUTHORIZED");
+	return { session };
+});
+/**
+* This middleware allows you to call the endpoint on the client if session is valid.
+* However, if called on the server, no session is required.
+*/
+const requestOnlySessionMiddleware = createAuthMiddleware(async (ctx) => {
+	const session = await getSessionFromCtx(ctx);
+	if (!session?.session && (ctx.request || ctx.headers)) throw new APIError("UNAUTHORIZED");
+	return { session };
+});
+/**
+* This middleware forces the endpoint to require a valid session,
+* as well as making sure the session is fresh before proceeding.
+*
+* Session freshness check will be skipped if the session config's freshAge
+* is set to 0
+*/
+const freshSessionMiddleware = createAuthMiddleware(async (ctx) => {
+	const session = await getSessionFromCtx(ctx);
+	if (!session?.session) throw new APIError("UNAUTHORIZED");
+	if (ctx.context.sessionConfig.freshAge === 0) return { session };
+	const freshAge = ctx.context.sessionConfig.freshAge;
+	const lastUpdated = session.session.updatedAt?.valueOf() || session.session.createdAt.valueOf();
+	if (!(Date.now() - lastUpdated < freshAge * 1e3)) throw new APIError("FORBIDDEN", { message: "Session is not fresh" });
+	return { session };
+});
+/**
+* user active sessions list
+*/
+const listSessions = () => createAuthEndpoint("/list-sessions", {
+	method: "GET",
+	use: [sessionMiddleware],
+	requireHeaders: true,
+	metadata: { openapi: {
+		description: "List all active sessions for the user",
+		responses: { "200": {
+			description: "Success",
+			content: { "application/json": { schema: {
+				type: "array",
+				items: { $ref: "#/components/schemas/Session" }
+			} } }
+		} }
+	} }
+}, async (ctx) => {
+	try {
+		const activeSessions = (await ctx.context.internalAdapter.listSessions(ctx.context.session.user.id)).filter((session) => {
+			return session.expiresAt > /* @__PURE__ */ new Date();
+		});
+		return ctx.json(activeSessions);
+	} catch (e) {
+		ctx.context.logger.error(e);
+		throw ctx.error("INTERNAL_SERVER_ERROR");
+	}
+});
+/**
+* revoke a single session
+*/
+const revokeSession = createAuthEndpoint("/revoke-session", {
+	method: "POST",
+	body: z$1.object({ token: z$1.string().meta({ description: "The token to revoke" }) }),
+	use: [sensitiveSessionMiddleware],
+	requireHeaders: true,
+	metadata: { openapi: {
+		description: "Revoke a single session",
+		requestBody: { content: { "application/json": { schema: {
+			type: "object",
+			properties: { token: {
+				type: "string",
+				description: "The token to revoke"
+			} },
+			required: ["token"]
+		} } } },
+		responses: { "200": {
+			description: "Success",
+			content: { "application/json": { schema: {
+				type: "object",
+				properties: { status: {
+					type: "boolean",
+					description: "Indicates if the session was revoked successfully"
+				} },
+				required: ["status"]
+			} } }
+		} }
+	} }
+}, async (ctx) => {
+	const token = ctx.body.token;
+	const findSession = await ctx.context.internalAdapter.findSession(token);
+	if (!findSession) throw new APIError("BAD_REQUEST", { message: "Session not found" });
+	if (findSession.session.userId !== ctx.context.session.user.id) throw new APIError("UNAUTHORIZED");
+	try {
+		await ctx.context.internalAdapter.deleteSession(token);
+	} catch (error) {
+		ctx.context.logger.error(error && typeof error === "object" && "name" in error ? error.name : "", error);
+		throw new APIError("INTERNAL_SERVER_ERROR");
+	}
+	return ctx.json({ status: true });
+});
+/**
+* revoke all user sessions
+*/
+const revokeSessions = createAuthEndpoint("/revoke-sessions", {
+	method: "POST",
+	use: [sensitiveSessionMiddleware],
+	requireHeaders: true,
+	metadata: { openapi: {
+		description: "Revoke all sessions for the user",
+		responses: { "200": {
+			description: "Success",
+			content: { "application/json": { schema: {
+				type: "object",
+				properties: { status: {
+					type: "boolean",
+					description: "Indicates if all sessions were revoked successfully"
+				} },
+				required: ["status"]
+			} } }
+		} }
+	} }
+}, async (ctx) => {
+	try {
+		await ctx.context.internalAdapter.deleteSessions(ctx.context.session.user.id);
+	} catch (error) {
+		ctx.context.logger.error(error && typeof error === "object" && "name" in error ? error.name : "", error);
+		throw new APIError("INTERNAL_SERVER_ERROR");
+	}
+	return ctx.json({ status: true });
+});
+const revokeOtherSessions = createAuthEndpoint("/revoke-other-sessions", {
+	method: "POST",
+	requireHeaders: true,
+	use: [sensitiveSessionMiddleware],
+	metadata: { openapi: {
+		description: "Revoke all other sessions for the user except the current one",
+		responses: { "200": {
+			description: "Success",
+			content: { "application/json": { schema: {
+				type: "object",
+				properties: { status: {
+					type: "boolean",
+					description: "Indicates if all other sessions were revoked successfully"
+				} },
+				required: ["status"]
+			} } }
+		} }
+	} }
+}, async (ctx) => {
+	const session = ctx.context.session;
+	if (!session.user) throw new APIError("UNAUTHORIZED");
+	const otherSessions = (await ctx.context.internalAdapter.listSessions(session.user.id)).filter((session$1) => {
+		return session$1.expiresAt > /* @__PURE__ */ new Date();
+	}).filter((session$1) => session$1.token !== ctx.context.session.session.token);
+	await Promise.all(otherSessions.map((session$1) => ctx.context.internalAdapter.deleteSession(session$1.token)));
+	return ctx.json({ status: true });
+});
+
+//#endregion
+export { requestOnlySessionMiddleware as a, revokeSessions as c, listSessions as i, sensitiveSessionMiddleware as l, getSession as n, revokeOtherSessions as o, getSessionFromCtx as r, revokeSession as s, freshSessionMiddleware as t, sessionMiddleware as u };

package/dist/social-providers/index.d.mts

@@ -0,0 +1 @@
+export * from "@gatwech/core/social-providers";

package/dist/social-providers/index.mjs

@@ -0,0 +1,3 @@
+export * from "@gatwech/core/social-providers"
+
+export {  };

package/dist/src/adapters/adapter-factory/index.d.ts

@@ -0,0 +1,10 @@
+import type { PayvoAuthOptions } from "@gatwech/core";
+import type { DBAdapter } from "@gatwech/core/db/adapter";
+import type { AdapterFactoryOptions } from "./types";
+export * from "./types";
+export type AdapterFactory = (options: PayvoAuthOptions) => DBAdapter<PayvoAuthOptions>;
+export declare const createAdapterFactory: ({ adapter: customAdapter, config: cfg, }: AdapterFactoryOptions) => AdapterFactory;
+/**
+ * @deprecated Use `createAdapterFactory` instead. This export will be removed in a future version.
+ */
+export declare const createAdapter: ({ adapter: customAdapter, config: cfg, }: AdapterFactoryOptions) => AdapterFactory;

package/dist/src/adapters/adapter-factory/types.d.ts

@@ -0,0 +1,124 @@
+import type { PayvoAuthOptions } from "@gatwech/core";
+import type { PayvoAuthDBSchema, DBFieldAttribute } from "@gatwech/core/db";
+import type { CustomAdapter as CoreCustomAdapter, DBAdapterFactoryConfig, DBAdapterSchemaCreation, DBTransactionAdapter } from "@gatwech/core/db/adapter";
+import type { Where } from "../../types";
+import type { Prettify } from "../../types/helper";
+export type AdapterFactoryOptions = {
+    config: DBAdapterFactoryConfig;
+    adapter: AdapterFactoryCustomizeAdapterCreator;
+};
+/**
+ * @deprecated Use `DBAdapterFactoryConfig` from `@gatwech/core/db/adapter` instead.
+ */
+export interface AdapterFactoryConfig extends Omit<DBAdapterFactoryConfig<PayvoAuthOptions>, "transaction"> {
+    /**
+     * Execute multiple operations in a transaction.
+     *
+     * If the database doesn't support transactions, set this to `false` and operations will be executed sequentially.
+     *
+     * @default false
+     */
+    transaction?: (false | (<R>(callback: (trx: DBTransactionAdapter) => Promise<R>) => Promise<R>)) | undefined;
+}
+export type AdapterFactoryCustomizeAdapterCreator = (config: {
+    options: PayvoAuthOptions;
+    /**
+     * The schema of the user's Payvo-Auth instance.
+     */
+    schema: PayvoAuthDBSchema;
+    /**
+     * The debug log function.
+     *
+     * If the config has defined `debugLogs` as `false`, no logs will be shown.
+     */
+    debugLog: (...args: any[]) => void;
+    /**
+     * Get the model name which is expected to be saved in the database based on the user's schema.
+     */
+    getModelName: (model: string) => string;
+    /**
+     * Get the field name which is expected to be saved in the database based on the user's schema.
+     */
+    getFieldName: ({ model, field }: {
+        model: string;
+        field: string;
+    }) => string;
+    /**
+     * This function helps us get the default model name from the schema defined by devs.
+     * Often times, the user will be using the `modelName` which could had been customized by the users.
+     * This function helps us get the actual model name useful to match against the schema. (eg: schema[model])
+     *
+     * If it's still unclear what this does:
+     *
+     * 1. User can define a custom modelName.
+     * 2. When using a custom modelName, doing something like `schema[model]` will not work.
+     * 3. Using this function helps us get the actual model name based on the user's defined custom modelName.
+     * 4. Thus allowing us to use `schema[model]`.
+     */
+    getDefaultModelName: (model: string) => string;
+    /**
+     * This function helps us get the default field name from the schema defined by devs.
+     * Often times, the user will be using the `fieldName` which could had been customized by the users.
+     * This function helps us get the actual field name useful to match against the schema. (eg: schema[model].fields[field])
+     *
+     * If it's still unclear what this does:
+     *
+     * 1. User can define a custom fieldName.
+     * 2. When using a custom fieldName, doing something like `schema[model].fields[field]` will not work.
+     *
+     */
+    getDefaultFieldName: ({ model, field, }: {
+        model: string;
+        field: string;
+    }) => string;
+    /**
+     * Get the field attributes for a given model and field.
+     *
+     * Note: any model name or field name is allowed, whether default to schema or not.
+     */
+    getFieldAttributes: ({ model, field, }: {
+        model: string;
+        field: string;
+    }) => DBFieldAttribute;
+    transformInput: (data: Record<string, any>, defaultModelName: string, action: "create" | "update", forceAllowId?: boolean | undefined) => Promise<Record<string, any>>;
+    transformOutput: (data: Record<string, any>, defaultModelName: string, select?: string[] | undefined) => Promise<Record<string, any>>;
+    transformWhereClause: <W extends Where[] | undefined>({ model, where, }: {
+        where: W;
+        model: string;
+    }) => W extends undefined ? undefined : CleanedWhere[];
+}) => CoreCustomAdapter;
+/**
+ * @deprecated Use `CustomAdapter` from `@gatwech/core/db/adapter` instead.
+ */
+export interface CustomAdapter extends Omit<CoreCustomAdapter, "createSchema"> {
+    createSchema?: ((props: {
+        /**
+         * The file the user may have passed in to the `generate` command as the expected schema file output path.
+         */
+        file?: string;
+        /**
+         * The tables from the user's Payvo-Auth instance schema.
+         */
+        tables: PayvoAuthDBSchema;
+    }) => Promise<DBAdapterSchemaCreation>) | undefined;
+}
+/**
+ * @deprecated Use `CleanedWhere` from `@gatwech/core/db/adapter` instead.
+ */
+export type CleanedWhere = Prettify<Required<Where>>;
+export type AdapterTestDebugLogs = {
+    resetDebugLogs: () => void;
+    printDebugLogs: () => void;
+};
+/**
+ * @deprecated Use `AdapterFactoryOptions` instead. This export will be removed in a future version.
+ */
+export type CreateAdapterOptions = AdapterFactoryOptions;
+/**
+ * @deprecated Use `AdapterFactoryConfig` instead. This export will be removed in a future version.
+ */
+export type AdapterConfig = DBAdapterFactoryConfig;
+/**
+ * @deprecated Use `AdapterFactoryCustomizeAdapterCreator` instead. This export will be removed in a future version.
+ */
+export type CreateCustomAdapter = AdapterFactoryCustomizeAdapterCreator;

package/dist/src/adapters/create-test-suite.d.ts

@@ -0,0 +1,97 @@
+import type { PayvoAuthOptions } from "@gatwech/core";
+import type { DBAdapter } from "@gatwech/core/db/adapter";
+import { payvoAuth } from "../auth";
+import type { Account, Session, User, Verification } from "../types";
+import type { Logger } from "./test-adapter";
+type GenerateFn = <M extends "user" | "session" | "verification" | "account">(Model: M) => Promise<M extends "user" ? User : M extends "session" ? Session : M extends "verification" ? Verification : M extends "account" ? Account : undefined>;
+type Success<T> = {
+    data: T;
+    error: null;
+};
+type Failure<E> = {
+    data: null;
+    error: E;
+};
+type Result<T, E = Error> = Success<T> | Failure<E>;
+export type InsertRandomFn = <M extends "user" | "session" | "verification" | "account", Count extends number = 1>(model: M, count?: Count | undefined) => Promise<Count extends 1 ? M extends "user" ? [User] : M extends "session" ? [User, Session] : M extends "verification" ? [Verification] : M extends "account" ? [User, Account] : [undefined] : Array<M extends "user" ? [User] : M extends "session" ? [User, Session] : M extends "verification" ? [Verification] : M extends "account" ? [User, Account] : [undefined]>>;
+export declare const createTestSuite2: <Tests extends Record<string, (context: {
+    /**
+     * Mark tests as skipped. All execution after this call will be skipped.
+     * This function throws an error, so make sure you are not catching it accidentally.
+     * @see {@link https://vitest.dev/guide/test-context#skip}
+     */
+    readonly skip: {
+        (note?: string | undefined): never;
+        (condition: boolean, note?: string | undefined): void;
+    };
+}) => Promise<void>>, AdditionalOptions extends Record<string, any> = {}>() => void;
+export declare const createTestSuite: <Tests extends Record<string, (context: {
+    /**
+     * Mark tests as skipped. All execution after this call will be skipped.
+     * This function throws an error, so make sure you are not catching it accidentally.
+     * @see {@link https://vitest.dev/guide/test-context#skip}
+     */
+    readonly skip: {
+        (note?: string | undefined): never;
+        (condition: boolean, note?: string | undefined): void;
+    };
+}) => Promise<void>>, AdditionalOptions extends Record<string, any> = {}>(suiteName: string, config: {
+    defaultPayvoAuthOptions?: PayvoAuthOptions | undefined;
+    /**
+     * Helpful if the default Payvo Auth options require migrations to be run.
+     */
+    alwaysMigrate?: boolean | undefined;
+    prefixTests?: string | undefined;
+}, tests: (helpers: {
+    adapter: DBAdapter<PayvoAuthOptions>;
+    log: Logger;
+    generate: GenerateFn;
+    insertRandom: InsertRandomFn;
+    /**
+     * A light cleanup function that will only delete rows it knows about.
+     */
+    cleanup: () => Promise<void>;
+    /**
+     * A hard cleanup function that will delete all rows from the database.
+     */
+    hardCleanup: () => Promise<void>;
+    modifyPayvoAuthOptions: (options: PayvoAuthOptions, shouldRunMigrations: boolean) => Promise<PayvoAuthOptions>;
+    getPayvoAuthOptions: () => PayvoAuthOptions;
+    sortModels: (models: Array<Record<string, any> & {
+        id: string;
+    }>, by?: ("id" | "createdAt") | undefined) => (Record<string, any> & {
+        id: string;
+    })[];
+    getAuth: () => Promise<ReturnType<typeof payvoAuth>>;
+    tryCatch<T, E = Error>(promise: Promise<T>): Promise<Result<T, E>>;
+    customIdGenerator?: () => any | Promise<any> | undefined;
+    transformIdOutput?: (id: any) => string | undefined;
+    /**
+     * Some adapters may change the ID type, this function allows you to pass the entire model
+     * data and it will return the correct payvo-auth-expected transformed data.
+     *
+     * Eg:
+     * MongoDB uses ObjectId for IDs, but it's possible the user can disable that option in the adapter config.
+     * Because of this, the expected data would be a string.
+     * These sorts of conversions will cause issues with the test when you use the `generate` function.
+     * This is because the `generate` function will return the raw data expected to be saved in DB, not the excpected BA output.
+     */
+    transformGeneratedModel: (data: Record<string, any>) => Record<string, any>;
+}, additionalOptions?: AdditionalOptions | undefined) => Tests) => (options?: ({
+    disableTests?: Partial<Record<keyof Tests, boolean> & {
+        ALL?: boolean;
+    }>;
+} & AdditionalOptions) | undefined) => (helpers: {
+    adapter: () => Promise<DBAdapter<PayvoAuthOptions>>;
+    log: Logger;
+    adapterDisplayName: string;
+    getPayvoAuthOptions: () => PayvoAuthOptions;
+    modifyPayvoAuthOptions: (options: PayvoAuthOptions) => Promise<PayvoAuthOptions>;
+    cleanup: () => Promise<void>;
+    runMigrations: () => Promise<void>;
+    prefixTests?: string | undefined;
+    onTestFinish: () => Promise<void>;
+    customIdGenerator?: () => any | Promise<any> | undefined;
+    transformIdOutput?: (id: any) => string | undefined;
+}) => Promise<void>;
+export {};