wabe 0.6.7 → 0.6.9

package/README.md

@@ -8,7 +8,9 @@
 
 ## What is Wabe?
 
-Wabe is an open-source backend as a service  that allows you to create your own fully customizable backend in just a few minutes. It handles database access, automatic GraphQL API generation, authentication with various methods (classic or OAuth), permissions, security, payment, emails, and more for you.
+Wabe is an open-source backend as a service that allows you to create your own fully customizable backend in just a few minutes. It handles database access, automatic GraphQL API generation, authentication with various methods (classic or OAuth), permissions, security, emails, and more for you.
+
+It requires Bun or Node > 24.7.
 
 ## Install
 
@@ -21,7 +23,8 @@ yarn add wabe # On yarn
 ## Basic example
 
 ```ts
-import { DatabaseEnum, Wabe } from "wabe";
+import { Wabe } from "wabe";
+import { MongoAdapter } from "wabe-mongodb";
 
 const run = async () => {
   // Ensure your database is running before run the file
@@ -32,11 +35,12 @@ const run = async () => {
     rootKey:
       "0uwFvUxM$ceFuF1aEtTtZMa7DUN2NZudqgY5ve5W*QCyb58cwMj9JeoaV@d#%29v&aJzswuudVU1%nAT+rxS0Bh&OkgBYc0PH18*",
     database: {
-      type: DatabaseEnum.Mongo,
-      url: "mongodb://127.0.0.1:27045",
-      name: "WabeApp",
+      adapter: new MongoAdapter({
+        databaseName: "WabeApp",
+        databaseUrl: "mongodb://127.0.0.1:27045",
+      }),
     },
-    port: 3000,
+    port: 3001,
   });
 
   await wabe.start();
@@ -53,7 +57,6 @@ await run();
 - **GraphQL API**: A flexible and powerful GraphQL API (following GraphQL Relay standard) to interact with your data.
 - **Hooks**: Powerful hooks system to execute custom actions before or after database requests.
 - **Email**: Send emails with your favorite provider with very simple integration.
-- **Payment**: Accept payments with Stripe or create your own payment provider adapter.
 
 ## Contributing
 

package/dist/authentication/OTP.d.ts

@@ -3,6 +3,14 @@ export declare class OTP {
 	private secret;
 	internalTotp: TOTP;
 	constructor(rootKey: string);
+	deriveSecret(userId: string): string;
 	generate(userId: string): string;
 	verify(otp: string, userId: string): boolean;
+	authenticatorGenerate(userId: string): string;
+	authenticatorVerify(otp: string, userId: string): boolean;
+	generateKeyuri({ userId, emailOrUsername, applicationName }: {
+		userId: string;
+		emailOrUsername: string;
+		applicationName: string;
+	}): string;
 }

package/dist/authentication/Session.d.ts

@@ -9,13 +9,13 @@ export declare class Session {
 	_getRefreshTokenExpiresInMs(config: WabeConfig<DevWabeTypes>);
 	getRefreshTokenExpireAt(config: WabeConfig<DevWabeTypes>);
 	meFromAccessToken(accessToken: string, context: WabeContext<DevWabeTypes>): Promise<{
-		sessionId: string | null
-		user: User | null
-		accessToken: string | null
-		refreshToken?: string | null
+		sessionId: string | null;
+		user: User | null;
+		accessToken: string | null;
+		refreshToken?: string | null;
 	}>;
 	create(userId: string, context: WabeContext<DevWabeTypes>);
+	refresh(accessToken: string, refreshToken: string, context: WabeContext<DevWabeTypes>);
 	delete(context: WabeContext<DevWabeTypes>);
 	_isRefreshTokenExpired(userRefreshTokenExpiresAt: Date, refreshTokenAgeInMs: number);
-	refresh(accessToken: string, refreshToken: string, context: WabeContext<DevWabeTypes>);
 }

package/dist/authentication/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./interface";
 export * from "./oauth";
+export * from "./OTP";

package/dist/authentication/interface.d.ts

@@ -2,9 +2,10 @@ import type { User } from "../../generated/wabe";
 import type { WabeContext } from "../server/interface";
 import type { SchemaFields } from "../schema";
 import type { WabeTypes, WobeCustomContext } from "../server";
+import type { SelectType } from "../database/interface";
 export declare enum ProviderEnum {
 	google = "google",
-	github = "github",
+	github = "github"
 }
 export interface ProviderConfig {
 	clientId: string;
@@ -14,50 +15,60 @@ export type AuthenticationEventsOptions<
 	T extends WabeTypes,
 	K
 > = {
-	context: WabeContext<T>
-	input: K
+	context: WabeContext<T>;
+	input: K;
 };
 export type AuthenticationEventsOptionsWithUserId<
 	T extends WabeTypes,
 	K
 > = AuthenticationEventsOptions<T, K> & {
-	userId: string
+	userId: string;
 };
 export type OnSendChallengeOptions<T extends WabeTypes> = {
-	context: WabeContext<T>
-	user: T["types"]["User"]
+	context: WabeContext<T>;
+	user: T["types"]["User"];
 };
 export type OnVerifyChallengeOptions<
 	T extends WabeTypes,
 	K
 > = {
-	context: WabeContext<T>
-	input: K
+	context: WabeContext<T>;
+	input: K;
 };
 export type ProviderInterface<
 	T extends WabeTypes,
 	K = any
 > = {
 	onSignIn: (options: AuthenticationEventsOptions<T, K>) => Promise<{
-		user: Partial<User>
-	}>
+		user: Partial<User>;
+		srp?: {
+			salt: string;
+			serverPublic: string;
+		};
+	}>;
 	onSignUp: (options: AuthenticationEventsOptions<T, K>) => Promise<{
-		authenticationDataToSave: any
-	}>
+		authenticationDataToSave: any;
+	}>;
 	onUpdateAuthenticationData?: (options: AuthenticationEventsOptionsWithUserId<T, K>) => Promise<{
-		authenticationDataToSave: any
-	}>
+		authenticationDataToSave: any;
+	}>;
 };
 export type SecondaryProviderInterface<
 	T extends WabeTypes,
 	K = any
 > = {
-	onSendChallenge: (options: OnSendChallengeOptions<T>) => Promise<void> | void
+	onSendChallenge?: (options: OnSendChallengeOptions<T>) => Promise<void> | void;
 	onVerifyChallenge: (options: OnVerifyChallengeOptions<T, K>) => Promise<{
-		userId: string
+		userId: string;
+		srp?: {
+			serverSessionProof: string;
+		};
 	} | null> | ({
-		userId: string
-	} | null)
+		userId: string;
+		srp?: {
+			serverSessionProof: string;
+		};
+	} | null);
 };
 export type CustomAuthenticationMethods<
 	T extends WabeTypes,
@@ -65,14 +76,14 @@ export type CustomAuthenticationMethods<
 	K = SchemaFields<T>,
 	W = SchemaFields<T>
 > = {
-	name: string
-	input: K
-	dataToStore?: W
-	provider: U
-	isSecondaryFactor?: boolean
+	name: string;
+	input: K;
+	dataToStore?: W;
+	provider: U;
+	isSecondaryFactor?: boolean;
 };
 export type RoleConfig = Array<string>;
-export interface SessionConfig {
+export interface SessionConfig<T extends WabeTypes> {
 	/**
 	* The time in milliseconds that the access token will expire
 	*/
@@ -89,9 +100,13 @@ export interface SessionConfig {
 	* The JWT secret used to sign the session tokens
 	*/
 	jwtSecret: string;
+	/**
+	* A selection of fields to include in the JWT token in the "user" fields
+	*/
+	jwtTokenFields?: SelectType<T, "User", keyof T["types"]["User"]>;
 }
 export interface AuthenticationConfig<T extends WabeTypes> {
-	session?: SessionConfig;
+	session?: SessionConfig<T>;
 	roles?: RoleConfig;
 	successRedirectPath?: string;
 	failureRedirectPath?: string;
@@ -100,6 +115,7 @@ export interface AuthenticationConfig<T extends WabeTypes> {
 	providers?: Partial<Record<ProviderEnum, ProviderConfig>>;
 	customAuthenticationMethods?: CustomAuthenticationMethods<T>[];
 	sessionHandler?: (context: WobeCustomContext<T>) => void | Promise<void>;
+	disableSignUp?: boolean;
 }
 export interface CreateTokenFromAuthorizationCodeOptions {
 	code: string;
@@ -115,8 +131,9 @@ export declare enum AuthenticationProvider {
 	GitHub = "github",
 	Google = "google",
 	EmailPassword = "emailPassword",
-	PhonePassword = "phonePassword",
+	PhonePassword = "phonePassword"
 }
 export declare enum SecondaryFactor {
 	EmailOTP = "emailOTP",
+	QRCodeOTP = "qrcodeOTP"
 }

package/dist/authentication/oauth/GitHub.d.ts

@@ -5,7 +5,7 @@ export declare class GitHub implements OAuth2ProviderWithPKCE {
 	private clientSecret;
 	constructor(config: WabeConfig<any>);
 	createAuthorizationURL(state: string, codeVerifier: string, options?: {
-		scopes?: string[]
+		scopes?: string[];
 	}): URL;
 	validateAuthorizationCode(code: string, codeVerifier: string): Promise<Tokens>;
 	refreshAccessToken(refreshToken: string): Promise<Tokens>;

package/dist/authentication/oauth/Google.d.ts

@@ -5,7 +5,7 @@ export declare class Google implements OAuth2ProviderWithPKCE {
 	private clientSecret;
 	constructor(config: WabeConfig<any>);
 	createAuthorizationURL(state: string, codeVerifier: string, options?: {
-		scopes?: string[]
+		scopes?: string[];
 	}): URL;
 	validateAuthorizationCode(code: string, codeVerifier: string): Promise<Tokens>;
 	refreshAccessToken(refreshToken: string): Promise<Tokens>;

package/dist/authentication/oauth/Oauth2Client.d.ts

@@ -12,22 +12,22 @@ export declare class OAuth2Client {
 	private redirectURI;
 	constructor(clientId: string, authorizeEndpoint: string, tokenEndpoint: string, redirectURI: string);
 	createAuthorizationURL(options?: {
-		state?: string
-		codeVerifier?: string
-		scopes?: string[]
+		state?: string;
+		codeVerifier?: string;
+		scopes?: string[];
 	}): URL;
 	validateAuthorizationCode<_TokenResponseBody extends TokenResponseBody>(authorizationCode: string, options?: {
-		codeVerifier?: string
-		credentials?: string
-		authenticateWith?: "http_basic_auth" | "request_body"
+		codeVerifier?: string;
+		credentials?: string;
+		authenticateWith?: "http_basic_auth" | "request_body";
 	}): Promise<_TokenResponseBody>;
 	refreshAccessToken<_TokenResponseBody extends TokenResponseBody>(refreshToken: string, options?: {
-		credentials?: string
-		authenticateWith?: "http_basic_auth" | "request_body"
-		scopes?: string[]
+		credentials?: string;
+		authenticateWith?: "http_basic_auth" | "request_body";
+		scopes?: string[];
 	}): Promise<_TokenResponseBody>;
 	_sendTokenRequest<_TokenResponseBody extends TokenResponseBody>(body: URLSearchParams, options?: {
-		credentials?: string
-		authenticateWith?: "http_basic_auth" | "request_body"
+		credentials?: string;
+		authenticateWith?: "http_basic_auth" | "request_body";
 	}): Promise<_TokenResponseBody>;
 }

package/dist/authentication/oauth/utils.d.ts

@@ -10,5 +10,6 @@ export interface OAuth2ProviderWithPKCE {
 	validateAuthorizationCode(code: string, codeVerifier: string): Promise<Tokens>;
 	refreshAccessToken?(refreshToken: string): Promise<Tokens>;
 }
+// https://datatracker.ietf.org/doc/html/rfc7636#appendix-A
 export declare const base64URLencode: unknown;
 export declare const generateRandomValues: unknown;

package/dist/authentication/providers/EmailOTP.d.ts

@@ -1,8 +1,8 @@
 import type { DevWabeTypes } from "../../utils/helper";
 import type { OnSendChallengeOptions, OnVerifyChallengeOptions, SecondaryProviderInterface } from "../interface";
 type EmailOTPInterface = {
-	email: string
-	otp: string
+	email: string;
+	otp: string;
 };
 export declare class EmailOTP implements SecondaryProviderInterface<DevWabeTypes, EmailOTPInterface> {
 	onSendChallenge({ context, user }: OnSendChallengeOptions<DevWabeTypes>);

package/dist/authentication/providers/EmailPassword.d.ts

@@ -1,9 +1,9 @@
 import type { AuthenticationEventsOptions, AuthenticationEventsOptionsWithUserId, ProviderInterface } from "../interface";
 import type { DevWabeTypes } from "../../utils/helper";
 type EmailPasswordInterface = {
-	password: string
-	email: string
-	otp?: string
+	password: string;
+	email: string;
+	otp?: string;
 };
 export declare class EmailPassword implements ProviderInterface<DevWabeTypes, EmailPasswordInterface> {
 	onSignIn({ input, context }: AuthenticationEventsOptions<DevWabeTypes, EmailPasswordInterface>);

package/dist/authentication/providers/EmailPasswordSRP.d.ts

@@ -0,0 +1,21 @@
+import type { AuthenticationEventsOptions, OnVerifyChallengeOptions, ProviderInterface, SecondaryProviderInterface } from "../interface";
+import type { DevWabeTypes } from "../../utils/helper";
+type EmailPasswordSRPInterface = {
+	clientPublic: string;
+	email: string;
+	salt?: string;
+	verifier?: string;
+};
+export declare class EmailPasswordSRP implements ProviderInterface<DevWabeTypes, EmailPasswordSRPInterface> {
+	onSignIn({ input, context }: AuthenticationEventsOptions<DevWabeTypes, EmailPasswordSRPInterface>);
+	onSignUp({ input, context }: AuthenticationEventsOptions<DevWabeTypes, EmailPasswordSRPInterface>);
+}
+export interface EmailPasswordSRPChallengeInterface {
+	email: string;
+	clientPublic: string;
+	clientSessionProof: string;
+}
+export declare class EmailPasswordSRPChallenge implements SecondaryProviderInterface<DevWabeTypes, EmailPasswordSRPChallengeInterface> {
+	onVerifyChallenge({ context, input }: OnVerifyChallengeOptions<DevWabeTypes, EmailPasswordSRPChallengeInterface>);
+}
+export {};

package/dist/authentication/providers/GitHub.d.ts

@@ -1,12 +1,13 @@
 import type { DevWabeTypes } from "../../utils/helper";
 import { type AuthenticationEventsOptions, type ProviderInterface } from "../interface";
 type GitHubInterface = {
-	authorizationCode: string
-	codeVerifier: string
+	authorizationCode: string;
+	codeVerifier: string;
 };
 export declare class GitHub implements ProviderInterface<DevWabeTypes, GitHubInterface> {
 	name: string;
 	onSignIn(options: AuthenticationEventsOptions<DevWabeTypes, GitHubInterface>);
+	// @ts-expect-error
 	onSignUp();
 }
 export {};

package/dist/authentication/providers/Google.d.ts

@@ -1,12 +1,13 @@
 import type { DevWabeTypes } from "../../utils/helper";
 import { type AuthenticationEventsOptions, type ProviderInterface } from "../interface";
 type GoogleInterface = {
-	authorizationCode: string
-	codeVerifier: string
+	authorizationCode: string;
+	codeVerifier: string;
 };
 export declare class Google implements ProviderInterface<DevWabeTypes, GoogleInterface> {
 	name: string;
 	onSignIn(options: AuthenticationEventsOptions<DevWabeTypes, GoogleInterface>);
+	// @ts-expect-error
 	onSignUp();
 }
 export {};

package/dist/authentication/providers/OAuth.d.ts

@@ -1,6 +1,6 @@
 export type OAuthAuthenticationInterface = {
-	authorizationCode: string
-	codeVerifier: string
+	authorizationCode: string;
+	codeVerifier: string;
 };
 export declare const getProvider: unknown;
 export declare const oAuthAuthentication: unknown;

package/dist/authentication/providers/PhonePassword.d.ts

@@ -1,9 +1,9 @@
 import type { AuthenticationEventsOptions, AuthenticationEventsOptionsWithUserId, ProviderInterface } from "../interface";
 import type { DevWabeTypes } from "../../utils/helper";
 type PhonePasswordInterface = {
-	password: string
-	phone: string
-	otp?: string
+	password: string;
+	phone: string;
+	otp?: string;
 };
 export declare class PhonePassword implements ProviderInterface<DevWabeTypes, PhonePasswordInterface> {
 	onSignIn({ input, context }: AuthenticationEventsOptions<DevWabeTypes, PhonePasswordInterface>);

package/dist/authentication/providers/QRCodeOTP.d.ts

@@ -0,0 +1,11 @@
+import type { DevWabeTypes } from "../../utils/helper";
+import type { OnVerifyChallengeOptions, SecondaryProviderInterface } from "../interface";
+type QRCodeOTPInterface = {
+	email: string;
+	otp: string;
+};
+export declare class QRCodeOTP implements SecondaryProviderInterface<DevWabeTypes, QRCodeOTPInterface> {
+	onSendChallenge();
+	onVerifyChallenge({ context, input }: OnVerifyChallengeOptions<DevWabeTypes, QRCodeOTPInterface>);
+}
+export {};

package/dist/authentication/providers/index.d.ts

@@ -3,3 +3,4 @@ export * from "./Google";
 export * from "./GitHub";
 export * from "./PhonePassword";
 export * from "./EmailOTP";
+export * from "./QRCodeOTP";

package/dist/authentication/resolvers/signInWithResolver.d.ts

@@ -1 +1,5 @@
+// 0 - Get the authentication method
+// 1 - We check if the signIn is possible (call onSign)
+// 2 - If secondaryFactor is present, we call the onSendChallenge method of the provider
+// 3 - We create session
 export declare const signInWithResolver: unknown;

package/dist/authentication/resolvers/signUpWithResolver.d.ts

@@ -1 +1,5 @@
+// 0 - Get the authentication method
+// 1 - We check if the signUp is possible (call onSign)
+// 2 - We create the user
+// 3 - We create session
 export declare const signUpWithResolver: unknown;

package/dist/authentication/utils.d.ts

@@ -5,4 +5,3 @@ export declare const getAuthenticationMethod: <
 	T extends WabeTypes,
 	U = ProviderInterface<T> | SecondaryProviderInterface<T>
 >(listOfMethods: string[], context: WabeContext<any>) => CustomAuthenticationMethods<T, U>;
-export declare const hashPassword: unknown;

package/dist/cron/index.d.ts

@@ -2,10 +2,10 @@ import { Cron } from "croner";
 import type { Wabe, WabeTypes } from "../server";
 export type OutputCron<T extends WabeTypes> = (wabe: Wabe<T>) => Cron;
 export declare const cron: <T extends WabeTypes>({ pattern, run, maxRuns, enabledProtectedRuns }: {
-	pattern: string
-	maxRuns?: number
-	enabledProtectedRuns?: boolean
-	run: (wabe: Wabe<T>) => any | Promise<any>
+	pattern: string;
+	maxRuns?: number;
+	enabledProtectedRuns?: boolean;
+	run: (wabe: Wabe<T>) => any | Promise<any>;
 }) => OutputCron<T>;
 export declare enum CronExpressions {
 	EVERY_SECOND = "* * * * * *",
@@ -23,10 +23,10 @@ export declare enum CronExpressions {
 	EVERY_30_MINUTES = "0 */30 * * * *",
 	EVERY_2_HOURS = "0 0 */2 * * *",
 	EVERY_6_HOURS = "0 0 */6 * * *",
-	EVERY_12_HOURS = "0 0 */12 * * *",
+	EVERY_12_HOURS = "0 0 */12 * * *"
 }
 export type CronConfig<T extends WabeTypes> = Array<{
-	name: string
-	cron: OutputCron<T>
-	job?: Cron
+	name: string;
+	cron: OutputCron<T>;
+	job?: Cron;
 }>;

package/dist/database/{controllers/DatabaseController.d.ts → DatabaseController.d.ts}

@@ -1,90 +1,92 @@
 import type { WabeTypes } from "../..";
-import type { WabeContext } from "../../server/interface";
-import type { CountOptions, CreateObjectOptions, CreateObjectsOptions, DatabaseAdapter, DeleteObjectOptions, DeleteObjectsOptions, GetObjectOptions, GetObjectsOptions, OutputType, UpdateObjectOptions, UpdateObjectsOptions, WhereType } from "../adapters/adaptersInterface";
+import type { SchemaInterface } from "../schema";
+import type { WabeContext } from "../server/interface";
+import type { CountOptions, CreateObjectOptions, CreateObjectsOptions, DatabaseAdapter, DeleteObjectOptions, DeleteObjectsOptions, GetObjectOptions, GetObjectsOptions, OutputType, UpdateObjectOptions, UpdateObjectsOptions, WhereType } from "./interface";
 export type Select = Record<string, boolean>;
 type SelectWithObject = Record<string, object | boolean>;
 export declare class DatabaseController<T extends WabeTypes> {
 	adapter: DatabaseAdapter<T>;
 	constructor(adapter: DatabaseAdapter<T>);
 	_getSelectMinusPointersAndRelations({ className, context, select }: {
-		className: keyof T["types"]
-		context: WabeContext<T>
-		select?: SelectWithObject
+		className: keyof T["types"];
+		context: WabeContext<T>;
+		select?: SelectWithObject;
 	}): {
+		// We associated the fieldName with a className and a select object
 		pointers: Record<string, {
-			className: string
-			select: Select
-		}>
-		selectWithoutPointers: Select
+			className: string;
+			select: Select;
+		}>;
+		selectWithoutPointers: Select;
 	};
 	_isRelationField({ pointerField, currentClassName, context, originClassName }: {
-		pointerField: string
-		originClassName: string
-		context: WabeContext<T>
-		currentClassName?: string
+		pointerField: string;
+		originClassName: string;
+		context: WabeContext<T>;
+		currentClassName?: string;
 	});
 	_isPointerField({ pointerField, currentClassName, context, originClassName }: {
-		originClassName: string
-		context: WabeContext<T>
-		pointerField: string
-		currentClassName?: string
+		originClassName: string;
+		context: WabeContext<T>;
+		pointerField: string;
+		currentClassName?: string;
 	});
 	_getWhereObjectWithPointerOrRelation<U extends keyof T["types"]>(className: U, where: WhereType<T, U>, context: WabeContext<T>);
 	_buildWhereWithACL<K extends keyof T["types"]>(where: WhereType<T, K>, context: WabeContext<T>, operation: "write" | "read"): WhereType<T, K>;
-	_getFinalObjectWithPointerAndRelation({ pointers, context, originClassName, object, isGraphQLCall }: {
-		originClassName: string
+	_getFinalObjectWithPointerAndRelation({ pointers, context, originClassName, object, _skipHooks }: {
+		originClassName: string;
 		pointers: Record<string, {
-			className: string
-			select: Select
-		}>
-		context: WabeContext<any>
-		object: Record<string, any>
-		isGraphQLCall?: boolean
+			className: string;
+			select: Select;
+		}>;
+		context: WabeContext<any>;
+		object: Record<string, any>;
+		_skipHooks?: boolean;
 	});
-	connect(): Promise<any>;
-	close(): Promise<any>;
-	createClassIfNotExist(className: string, context: WabeContext<T>): Promise<any>;
+	close();
+	createClassIfNotExist(className: string, schema: SchemaInterface<T>): Promise<any>;
+	initializeDatabase(schema: SchemaInterface<T>): Promise<void>;
 	count<K extends keyof T["types"]>({ className, context, where }: CountOptions<T, K>): Promise<number>;
 	clearDatabase(): Promise<void>;
 	getObject<
 		K extends keyof T["types"],
 		U extends keyof T["types"][K]
-	>({ select, className, context, skipHooks, id, where, isGraphQLCall }: GetObjectOptions<T, K, U>): Promise<OutputType<T, K, U>>;
+	>({ select, className, context, _skipHooks, id, where }: GetObjectOptions<T, K, U>): Promise<OutputType<T, K, U>>;
 	getObjects<
 		K extends keyof T["types"],
 		U extends keyof T["types"][K],
 		W extends keyof T["types"][K]
-	>({ className, select, context, where, skipHooks, first, offset, order, isGraphQLCall }: GetObjectsOptions<T, K, U, W>): Promise<OutputType<T, K, W>[]>;
+	>({ className, select, context, where, _skipHooks, first, offset, order }: GetObjectsOptions<T, K, U, W>): Promise<OutputType<T, K, W>[]>;
 	createObject<
 		K extends keyof T["types"],
 		U extends keyof T["types"][K],
 		W extends keyof T["types"][K]
-	>({ className, context, data, select, isGraphQLCall }: CreateObjectOptions<T, K, U, W>): Promise<OutputType<T, K, W>>;
+	>({ className, context, data, select }: CreateObjectOptions<T, K, U, W>): Promise<OutputType<T, K, W>>;
 	createObjects<
 		K extends keyof T["types"],
 		U extends keyof T["types"][K],
 		W extends keyof T["types"][K],
 		X extends keyof T["types"][K]
-	>({ data, select, className, context, first, offset, order, isGraphQLCall }: CreateObjectsOptions<T, K, U, W, X>): Promise<OutputType<T, K, W>[]>;
+	>({ data, select, className, context, first, offset, order }: CreateObjectsOptions<T, K, U, W, X>): Promise<OutputType<T, K, W>[]>;
 	updateObject<
 		K extends keyof T["types"],
 		U extends keyof T["types"][K],
 		W extends keyof T["types"][K]
-	>({ id, className, context, data, select, skipHooks, isGraphQLCall }: UpdateObjectOptions<T, K, U, W>): Promise<OutputType<T, K, W>>;
+	>({ id, className, context, data, select, _skipHooks }: UpdateObjectOptions<T, K, U, W>): Promise<OutputType<T, K, W>>;
 	updateObjects<
 		K extends keyof T["types"],
 		U extends keyof T["types"][K],
 		W extends keyof T["types"][K],
 		X extends keyof T["types"][K]
-	>({ className, where, context, select, data, first, offset, order, skipHooks, isGraphQLCall }: UpdateObjectsOptions<T, K, U, W, X>): Promise<OutputType<T, K, W>[]>;
+	>({ className, where, context, select, data, first, offset, order, _skipHooks }: UpdateObjectsOptions<T, K, U, W, X>): Promise<OutputType<T, K, W>[]>;
 	deleteObject<
 		K extends keyof T["types"],
 		U extends keyof T["types"][K]
-	>({ context, className, id, select, isGraphQLCall }: DeleteObjectOptions<T, K, U>): Promise<OutputType<T, K, U>>;
+	>({ context, className, id, select }: DeleteObjectOptions<T, K, U>): Promise<OutputType<T, K, U>>;
 	deleteObjects<
 		K extends keyof T["types"],
 		U extends keyof T["types"][K],
 		W extends keyof T["types"][K]
-	>({ className, context, select, where, first, offset, order, isGraphQLCall }: DeleteObjectsOptions<T, K, U, W>): Promise<OutputType<T, K, W>[]>;
+	>({ className, context, select, where, first, offset, order }: DeleteObjectsOptions<T, K, U, W>): Promise<OutputType<T, K, W>[]>;
 }
 export {};

package/dist/database/index.d.ts

@@ -1,10 +1,7 @@
-export declare enum DatabaseEnum {
-	Mongo = "mongo",
+import type { WabeTypes } from "../server";
+import type { DatabaseAdapter } from "./interface";
+export interface DatabaseConfig<T extends WabeTypes> {
+	adapter: DatabaseAdapter<T>;
 }
-export interface DatabaseConfig {
-	type: DatabaseEnum;
-	url: string;
-	name: string;
-}
-export * from "./adapters";
-export * from "./controllers";
+export * from "./DatabaseController";
+export * from "./interface";