wabe 0.6.4 → 0.6.5

package/README.md

@@ -8,7 +8,7 @@
 
 ## What is Wabe?
 
-Wabe is an open-source backend 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, payment, emails, and more for you.
 
 ## Install
 
@@ -27,6 +27,7 @@ const run = async () => {
   // Ensure your database is running before run the file
 
   const wabe = new Wabe({
+    isProduction: process.env.NODE_ENV === "production",
     // Root key example (must be long minimal 64 characters, you can generate it online)
     rootKey:
       "0uwFvUxM$ceFuF1aEtTtZMa7DUN2NZudqgY5ve5W*QCyb58cwMj9JeoaV@d#%29v&aJzswuudVU1%nAT+rxS0Bh&OkgBYc0PH18*",

package/dist/ai/index.d.ts

@@ -0,0 +1 @@
+export * from "./interface";

package/dist/ai/interface.d.ts

@@ -0,0 +1,9 @@
+export interface CreateCompletionOptions {
+	content: string;
+}
+export interface AIAdapter {
+	createCompletion(options: CreateCompletionOptions): Promise<string>;
+}
+export interface AIConfig {
+	adapter: AIAdapter;
+}

package/dist/authentication/OTP.d.ts

@@ -0,0 +1,8 @@
+import type { TOTP } from "otplib/core";
+export declare class OTP {
+	private secret;
+	internalTotp: TOTP;
+	constructor(rootKey: string);
+	generate(userId: string): string;
+	verify(otp: string, userId: string): boolean;
+}

package/dist/authentication/Session.d.ts

@@ -0,0 +1,21 @@
+import type { WabeContext } from "../server/interface";
+import type { User } from "../../generated/wabe";
+import type { WabeConfig } from "../server";
+import type { DevWabeTypes } from "../utils/helper";
+export declare class Session {
+	private accessToken;
+	private refreshToken;
+	getAccessTokenExpireAt(config: WabeConfig<DevWabeTypes>);
+	_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
+	}>;
+	create(userId: string, context: WabeContext<DevWabeTypes>);
+	delete(context: WabeContext<DevWabeTypes>);
+	_isRefreshTokenExpired(userRefreshTokenExpiresAt: Date, refreshTokenAgeInMs: number);
+	refresh(accessToken: string, refreshToken: string, context: WabeContext<DevWabeTypes>);
+}

package/dist/authentication/defaultAuthentication.d.ts

@@ -0,0 +1,3 @@
+import type { WabeTypes } from "..";
+import type { CustomAuthenticationMethods, ProviderInterface } from "./interface";
+export declare const defaultAuthenticationMethods: <T extends WabeTypes>() => CustomAuthenticationMethods<T, ProviderInterface<T>>[];

package/dist/authentication/index.d.ts

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

package/dist/authentication/interface.d.ts

@@ -0,0 +1,118 @@
+import type { User } from "../../generated/wabe";
+import type { WabeContext } from "../server/interface";
+import type { SchemaFields } from "../schema";
+import type { WabeTypes, WobeCustomContext } from "../server";
+export declare enum ProviderEnum {
+	google = "google",
+	github = "github",
+}
+export interface ProviderConfig {
+	clientId: string;
+	clientSecret: string;
+}
+export type AuthenticationEventsOptions<
+	T extends WabeTypes,
+	K
+> = {
+	context: WabeContext<T>
+	input: K
+};
+export type AuthenticationEventsOptionsWithUserId<
+	T extends WabeTypes,
+	K
+> = AuthenticationEventsOptions<T, K> & {
+	userId: string
+};
+export type OnSendChallengeOptions<T extends WabeTypes> = {
+	context: WabeContext<T>
+	user: T["types"]["User"]
+};
+export type OnVerifyChallengeOptions<
+	T extends WabeTypes,
+	K
+> = {
+	context: WabeContext<T>
+	input: K
+};
+export type ProviderInterface<
+	T extends WabeTypes,
+	K = any
+> = {
+	onSignIn: (options: AuthenticationEventsOptions<T, K>) => Promise<{
+		user: Partial<User>
+	}>
+	onSignUp: (options: AuthenticationEventsOptions<T, K>) => Promise<{
+		authenticationDataToSave: any
+	}>
+	onUpdateAuthenticationData?: (options: AuthenticationEventsOptionsWithUserId<T, K>) => Promise<{
+		authenticationDataToSave: any
+	}>
+};
+export type SecondaryProviderInterface<
+	T extends WabeTypes,
+	K = any
+> = {
+	onSendChallenge: (options: OnSendChallengeOptions<T>) => Promise<void> | void
+	onVerifyChallenge: (options: OnVerifyChallengeOptions<T, K>) => Promise<{
+		userId: string
+	} | null> | ({
+		userId: string
+	} | null)
+};
+export type CustomAuthenticationMethods<
+	T extends WabeTypes,
+	U = ProviderInterface<T> | SecondaryProviderInterface<T>,
+	K = SchemaFields<T>,
+	W = SchemaFields<T>
+> = {
+	name: string
+	input: K
+	dataToStore?: W
+	provider: U
+	isSecondaryFactor?: boolean
+};
+export type RoleConfig = Array<string>;
+export interface SessionConfig {
+	/**
+	* The time in milliseconds that the access token will expire
+	*/
+	accessTokenExpiresInMs?: number;
+	/**
+	* The time in milliseconds that the refresh token will expire
+	*/
+	refreshTokenExpiresInMs?: number;
+	/**
+	* Set to true to automatically store the session tokens in cookies
+	*/
+	cookieSession?: boolean;
+}
+export interface AuthenticationConfig<T extends WabeTypes> {
+	session?: SessionConfig;
+	roles?: RoleConfig;
+	successRedirectPath?: string;
+	failureRedirectPath?: string;
+	frontDomain?: string;
+	backDomain?: string;
+	providers?: Partial<Record<ProviderEnum, ProviderConfig>>;
+	customAuthenticationMethods?: CustomAuthenticationMethods<T>[];
+	sessionHandler?: (context: WobeCustomContext<T>) => void | Promise<void>;
+}
+export interface CreateTokenFromAuthorizationCodeOptions {
+	code: string;
+}
+export interface refreshTokenOptions {
+	refreshToken: string;
+}
+export interface Provider {
+	createTokenFromAuthorizationCode(options: CreateTokenFromAuthorizationCodeOptions): Promise<void>;
+	refreshToken(options: refreshTokenOptions): Promise<void>;
+}
+export declare enum AuthenticationProvider {
+	GitHub = "github",
+	Google = "google",
+	EmailPassword = "emailPassword",
+	PhonePassword = "phonePassword",
+}
+export declare enum SecondaryFactor {
+	EmailOTP = "emailOTP",
+}

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

@@ -0,0 +1,13 @@
+import type { WabeConfig } from "../../server";
+import type { OAuth2ProviderWithPKCE, Tokens } from "./utils";
+export declare class GitHub implements OAuth2ProviderWithPKCE {
+	private client;
+	private clientSecret;
+	constructor(config: WabeConfig<any>);
+	createAuthorizationURL(state: string, codeVerifier: string, options?: {
+		scopes?: string[]
+	}): URL;
+	validateAuthorizationCode(code: string, codeVerifier: string): Promise<Tokens>;
+	refreshAccessToken(refreshToken: string): Promise<Tokens>;
+	getUserInfo(accessToken: string);
+}

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

@@ -0,0 +1,13 @@
+import type { WabeConfig } from "../../server";
+import type { OAuth2ProviderWithPKCE, Tokens } from "./utils";
+export declare class Google implements OAuth2ProviderWithPKCE {
+	private client;
+	private clientSecret;
+	constructor(config: WabeConfig<any>);
+	createAuthorizationURL(state: string, codeVerifier: string, options?: {
+		scopes?: string[]
+	}): URL;
+	validateAuthorizationCode(code: string, codeVerifier: string): Promise<Tokens>;
+	refreshAccessToken(refreshToken: string): Promise<Tokens>;
+	getUserInfo(accessToken: string);
+}

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

@@ -0,0 +1,33 @@
+export interface TokenResponseBody {
+	access_token: string;
+	token_type?: string;
+	expires_in?: number;
+	refresh_token?: string;
+	scope?: string;
+}
+export declare class OAuth2Client {
+	clientId: string;
+	private authorizeEndpoint;
+	private tokenEndpoint;
+	private redirectURI;
+	constructor(clientId: string, authorizeEndpoint: string, tokenEndpoint: string, redirectURI: string);
+	createAuthorizationURL(options?: {
+		state?: string
+		codeVerifier?: string
+		scopes?: string[]
+	}): URL;
+	validateAuthorizationCode<_TokenResponseBody extends TokenResponseBody>(authorizationCode: string, options?: {
+		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[]
+	}): Promise<_TokenResponseBody>;
+	_sendTokenRequest<_TokenResponseBody extends TokenResponseBody>(body: URLSearchParams, options?: {
+		credentials?: string
+		authenticateWith?: "http_basic_auth" | "request_body"
+	}): Promise<_TokenResponseBody>;
+}

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

@@ -0,0 +1,2 @@
+export * from "./Oauth2Client";
+export * from "./Google";

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

@@ -0,0 +1,14 @@
+export interface Tokens {
+	accessToken: string;
+	refreshToken?: string | null;
+	accessTokenExpiresAt?: Date;
+	refreshTokenExpiresAt?: Date | null;
+	idToken?: string;
+}
+export interface OAuth2ProviderWithPKCE {
+	createAuthorizationURL(state: string, codeVerifier: string): URL;
+	validateAuthorizationCode(code: string, codeVerifier: string): Promise<Tokens>;
+	refreshAccessToken?(refreshToken: string): Promise<Tokens>;
+}
+export declare const base64URLencode: unknown;
+export declare const generateRandomValues: unknown;

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,5 @@
+export * from "./EmailPassword";
+export * from "./Google";
+export * from "./GitHub";
+export * from "./PhonePassword";
+export * from "./EmailOTP";

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

@@ -0,0 +1 @@
+export declare const refreshResolver: unknown;

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

@@ -0,0 +1 @@
+export declare const signInWithResolver: unknown;

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

@@ -0,0 +1 @@
+export declare const signOutResolver: unknown;

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

@@ -0,0 +1 @@
+export declare const signUpWithResolver: unknown;

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

@@ -0,0 +1 @@
+export declare const verifyChallengeResolver: unknown;

package/dist/authentication/roles.d.ts

@@ -0,0 +1 @@
+export declare const initializeRoles: unknown;

package/dist/authentication/srp/processSRPChallenge.d.ts

@@ -0,0 +1 @@
+export declare const processSRPChallenge: unknown;

package/dist/authentication/srp/signInWithSRP.d.ts

@@ -0,0 +1 @@
+export declare const signInWithSRP: unknown;

package/dist/authentication/srp/signUpWithSRP.d.ts

@@ -0,0 +1 @@
+export declare const signUpWithSRP: unknown;

package/dist/authentication/utils.d.ts

@@ -0,0 +1,8 @@
+import type { WabeTypes } from "../server";
+import type { WabeContext } from "../server/interface";
+import type { CustomAuthenticationMethods, ProviderInterface, SecondaryProviderInterface } from "./interface";
+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

@@ -0,0 +1,32 @@
+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>
+}) => OutputCron<T>;
+export declare enum CronExpressions {
+	EVERY_SECOND = "* * * * * *",
+	EVERY_MINUTE = "0 * * * * *",
+	EVERY_HOUR = "0 0 * * * *",
+	EVERY_DAY_AT_MIDNIGHT = "0 0 0 * * *",
+	EVERY_WEEK = "0 0 0 * * 0",
+	EVERY_MONTH = "0 0 0 1 * *",
+	EVERY_YEAR = "0 0 0 1 1 *",
+	WEEKDAYS_MORNING = "0 0 7 * * 1-5",
+	WEEKENDS_EVENING = "0 0 19 * * 6-7",
+	FIRST_DAY_OF_MONTH = "0 0 0 1 * *",
+	LAST_DAY_OF_MONTH = "0 0 0 L * *",
+	EVERY_15_MINUTES = "0 */15 * * * *",
+	EVERY_30_MINUTES = "0 */30 * * * *",
+	EVERY_2_HOURS = "0 0 */2 * * *",
+	EVERY_6_HOURS = "0 0 */6 * * *",
+	EVERY_12_HOURS = "0 0 */12 * * *",
+}
+export type CronConfig<T extends WabeTypes> = Array<{
+	name: string
+	cron: OutputCron<T>
+	job?: Cron
+}>;

package/dist/database/adapters/MongoAdapter.d.ts

@@ -0,0 +1,64 @@
+import { type Db, MongoClient } from "mongodb";
+import type { AdapterOptions, DatabaseAdapter, GetObjectOptions, CreateObjectOptions, UpdateObjectOptions, GetObjectsOptions, CreateObjectsOptions, UpdateObjectsOptions, DeleteObjectsOptions, WhereType, DeleteObjectOptions, OutputType, CountOptions, OrderType } from "./adaptersInterface";
+import type { WabeTypes } from "../../server";
+import type { WabeContext } from "../../server/interface";
+export declare const buildMongoOrderQuery: <
+	T extends WabeTypes,
+	K extends keyof T["types"],
+	U extends keyof T["types"][K]
+>(order?: OrderType<T, K, U>) => Record<string, any>;
+export declare const buildMongoWhereQuery: <
+	T extends WabeTypes,
+	K extends keyof T["types"]
+>(where?: WhereType<T, K>) => Record<string, any>;
+export declare class MongoAdapter<T extends WabeTypes> implements DatabaseAdapter<T> {
+	options: AdapterOptions;
+	database?: Db;
+	client: MongoClient;
+	constructor(options: AdapterOptions);
+	connect();
+	close();
+	createClassIfNotExist(className: keyof T["types"], context: WabeContext<T>);
+	count<K extends keyof T["types"]>(params: CountOptions<T, K>);
+	clearDatabase();
+	getObject<
+		K extends keyof T["types"],
+		U extends keyof T["types"][K]
+	>(params: 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]
+	>(params: 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]
+	>(params: CreateObjectOptions<T, K, U, 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]
+	>(params: CreateObjectsOptions<T, K, U, W, X>);
+	updateObject<
+		K extends keyof T["types"],
+		U extends keyof T["types"][K],
+		W extends keyof T["types"][K]
+	>(params: UpdateObjectOptions<T, K, U, 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]
+	>(params: UpdateObjectsOptions<T, K, U, W, X>);
+	deleteObject<
+		K extends keyof T["types"],
+		U extends keyof T["types"][K]
+	>(params: DeleteObjectOptions<T, K, U>);
+	deleteObjects<
+		K extends keyof T["types"],
+		U extends keyof T["types"][U],
+		W extends keyof T["types"][U]
+	>(params: DeleteObjectsOptions<T, K, U, W>);
+}