wabe 0.6.11 → 0.6.13

package/dist/authentication/Session.d.ts

@@ -1,24 +1,22 @@
 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 {
+import type { WabeConfig, WabeTypes } from "../server";
+export declare class Session<T extends WabeTypes> {
 	private accessToken;
 	private refreshToken;
-	getAccessTokenExpireAt(config: WabeConfig<DevWabeTypes>);
-	_getRefreshTokenExpiresInMs(config: WabeConfig<DevWabeTypes>);
-	getRefreshTokenExpireAt(config: WabeConfig<DevWabeTypes>);
+	getAccessTokenExpireAt(config: WabeConfig<T>);
+	_getRefreshTokenExpiresInMs(config: WabeConfig<T>);
+	getRefreshTokenExpireAt(config: WabeConfig<T>);
 	meFromAccessToken({ accessToken, csrfToken }: {
 		accessToken: string;
 		csrfToken: string;
-	}, context: WabeContext<DevWabeTypes>): Promise<{
+	}, context: WabeContext<T>): Promise<{
 		sessionId: string | null;
-		user: User | null;
+		user: T["types"]["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>);
+	create(userId: string, context: WabeContext<T>);
+	refresh(accessToken: string, refreshToken: string, context: WabeContext<T>);
+	delete(context: WabeContext<T>);
 	_isRefreshTokenExpired(userRefreshTokenExpiresAt: Date, refreshTokenAgeInMs: number);
 }

package/dist/authentication/cookies.d.ts

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

package/dist/authentication/index.d.ts

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

package/dist/authentication/interface.d.ts

@@ -121,6 +121,25 @@ export interface SessionConfig<T extends WabeTypes> {
 	*/
 	jwtTokenFields?: SelectType<T, "User", keyof T["types"]["User"]>;
 }
+export interface AuthenticationRateLimitConfig {
+	/**
+	* Enable this rate limiter. Enabled by default in production.
+	*/
+	enabled?: boolean;
+	maxAttempts?: number;
+	windowMs?: number;
+	blockDurationMs?: number;
+}
+export interface AuthenticationSecurityConfig {
+	signInRateLimit?: AuthenticationRateLimitConfig;
+	signUpRateLimit?: AuthenticationRateLimitConfig;
+	verifyChallengeRateLimit?: AuthenticationRateLimitConfig;
+	mfaChallengeTtlMs?: number;
+	/**
+	* Require a valid challenge token during verifyChallenge in production.
+	*/
+	requireMfaChallengeInProduction?: boolean;
+}
 export interface AuthenticationConfig<T extends WabeTypes> {
 	session?: SessionConfig<T>;
 	roles?: RoleConfig;
@@ -132,6 +151,7 @@ export interface AuthenticationConfig<T extends WabeTypes> {
 	customAuthenticationMethods?: CustomAuthenticationMethods<T>[];
 	sessionHandler?: (context: WobeCustomContext<T>) => void | Promise<void>;
 	disableSignUp?: boolean;
+	security?: AuthenticationSecurityConfig;
 }
 export interface CreateTokenFromAuthorizationCodeOptions {
 	code: string;

package/dist/authentication/security.d.ts

@@ -0,0 +1,18 @@
+import type { WabeContext } from "../server/interface";
+import type { WabeTypes } from "../server";
+import { DevWabeTypes } from "src/utils/helper";
+type RateLimitScope = "signIn" | "signUp" | "verifyChallenge";
+export declare const isRateLimited: <T extends WabeTypes>(context: WabeContext<T>, scope: RateLimitScope, key: string) => boolean;
+export declare const registerRateLimitFailure: unknown;
+export declare const clearRateLimit: unknown;
+export declare const createMfaChallenge: (context: WabeContext<DevWabeTypes>, { userId, provider }: {
+	userId: string;
+	provider: string;
+}) => Promise<string>;
+export declare const consumeMfaChallenge: (context: WabeContext<DevWabeTypes>, { challengeToken, userId, provider }: {
+	challengeToken: string;
+	userId: string;
+	provider: string;
+}) => Promise<boolean>;
+export declare const shouldRequireMfaChallenge: unknown;
+export {};

package/dist/database/DatabaseController.d.ts

@@ -2,7 +2,7 @@ import type { WabeTypes } from "../..";
 import { OperationType } from "../hooks";
 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";
+import { type CountOptions, type CreateObjectOptions, type CreateObjectsOptions, type DatabaseAdapter, type DeleteObjectOptions, type DeleteObjectsOptions, type GetObjectOptions, type GetObjectsOptions, type OutputType, type UpdateObjectOptions, type UpdateObjectsOptions, type WhereType } from "./interface";
 export type Select = Record<string, boolean>;
 type SelectWithObject = Record<string, object | boolean>;
 export declare class DatabaseController<T extends WabeTypes> {
@@ -19,6 +19,43 @@ export declare class DatabaseController<T extends WabeTypes> {
 		type: string;
 		class?: string;
 	} | undefined;
+	_getVirtualFieldsForClass(className: keyof T["types"], context: WabeContext<T>);
+	_buildReadSelects({ className, context, selectWithoutPointers }: {
+		className: keyof T["types"];
+		context: WabeContext<T>;
+		selectWithoutPointers: Select;
+	}): {};
+	_buildHookReadSelect({ className, context, userSelect, selectWithoutPointers }: {
+		className: keyof T["types"];
+		context: WabeContext<T>;
+		userSelect: Select;
+		selectWithoutPointers: Select;
+	}): Select;
+	_initializeReadHook<K extends keyof T["types"]>({ className, context, userSelect, selectWithoutPointers, _skipHooks }: {
+		className: K;
+		context: WabeContext<T>;
+		userSelect: Select;
+		selectWithoutPointers: Select;
+		_skipHooks?: boolean;
+	});
+	_buildSelectWithPointers({ adapterSelect, pointers }: {
+		adapterSelect: Select;
+		pointers: Record<string, {
+			className: string;
+			select: Select;
+		}>;
+	});
+	_isEmptySelect(select?: Record<string, unknown>): boolean;
+	_projectObjectForUserSelect({ object, select }: {
+		object: Record<string, any> | null | undefined;
+		select?: SelectWithObject;
+	}): any;
+	_stripVirtualFieldsFromPayload({ className, context, payload }: {
+		className: keyof T["types"];
+		context: WabeContext<T>;
+		payload: unknown;
+	}): any;
+	_stripVirtualFieldsFromSchema(schema: SchemaInterface<T>): SchemaInterface<T>;
 	_getSelectMinusPointersAndRelations({ className, context, select }: {
 		className: keyof T["types"];
 		context: WabeContext<T>;
@@ -61,14 +98,31 @@ export declare class DatabaseController<T extends WabeTypes> {
 			id: string;
 		} | null>;
 	});
+	_getRelationSelectWithoutTotalCount(currentSelect?: Select): Select;
+	_resolvePointerField({ currentClassName, object, pointerField, currentSelect, context, _skipHooks }: {
+		currentClassName: string;
+		object: Record<string, any>;
+		pointerField: string;
+		currentSelect?: Select;
+		context: WabeContext<any>;
+		_skipHooks?: boolean;
+	});
+	_resolveRelationField({ currentClassName, object, pointerField, currentSelect, context, _skipHooks }: {
+		currentClassName: string;
+		object: Record<string, any>;
+		pointerField: string;
+		currentSelect?: Select;
+		context: WabeContext<any>;
+		_skipHooks?: boolean;
+	});
 	_getFinalObjectWithPointerAndRelation({ pointers, context, originClassName, object, _skipHooks }: {
-		originClassName: string;
+		originClassName: keyof T["types"];
 		pointers: Record<string, {
 			className: string;
 			select: Select;
 		}>;
 		context: WabeContext<any>;
-		object: Record<string, any>;
+		object: Record<string, any> | null | undefined;
 		_skipHooks?: boolean;
 	});
 	close();

package/dist/database/interface.d.ts

@@ -46,6 +46,11 @@ export type WhereType<
 	T extends WabeTypes,
 	K = keyof T["where"]
 > = Partial<WhereAggregation<T, K>> & WhereConditional<T, K>;
+/** Structure for relation where input (have / isEmpty) */
+export type RelationWhereInput<THave = unknown> = {
+	have?: THave;
+	isEmpty?: boolean;
+};
 type SelectObject<
 	T,
 	K extends WabeTypes,

package/dist/file/interface.d.ts

@@ -1,4 +1,26 @@
 import type { WabeContext, WabeTypes } from "src/server";
+export type FileUploadSecurityConfig = {
+	/**
+	* Enable upload validation rules. Enabled by default in production.
+	*/
+	enabled?: boolean;
+	/**
+	* Maximum allowed file size in bytes.
+	*/
+	maxFileSizeBytes?: number;
+	/**
+	* Allowlist of MIME types accepted by uploads.
+	*/
+	allowedMimeTypes?: string[];
+	/**
+	* Allowlist of file extensions accepted by uploads (without dot).
+	*/
+	allowedExtensions?: string[];
+	/**
+	* Randomize uploaded file names (enabled by default in production).
+	*/
+	randomizeFileName?: boolean;
+};
 /**
 * The file config contains the adapter to use to upload file
 * @param adapter: FileAdapter
@@ -10,6 +32,7 @@ export type FileConfig<T extends WabeTypes> = {
 	urlCacheInSeconds?: number;
 	devDirectory?: string;
 	beforeUpload?: (file: File, context: WabeContext<T>) => Promise<File> | File;
+	security?: FileUploadSecurityConfig;
 };
 export interface ReadFileOptions {
 	urlExpiresIn?: number;

package/dist/file/security.d.ts

@@ -0,0 +1,6 @@
+import type { WabeContext, WabeTypes } from "src/server";
+import type { FileUploadSecurityConfig } from "./interface";
+declare const getUploadSecurityConfig: <T extends WabeTypes>(context: WabeContext<T>) => {};
+export declare const secureUploadedFile: <T extends WabeTypes>(file: File, context: WabeContext<T>) => Promise<File>;
+export declare const getUploadSecurityConfigForTests: <T extends WabeTypes>(context: WabeContext<T>) => ReturnType<typeof getUploadSecurityConfig>;
+export type { FileUploadSecurityConfig };

package/dist/graphql/GraphQLSchema.d.ts

@@ -2,7 +2,7 @@ import { GraphQLEnumType, type GraphQLFieldConfig, GraphQLInputObjectType, Graph
 import type { ClassInterface, MutationResolver, QueryResolver, Schema, SchemaFields } from "../schema";
 import type { DevWabeTypes } from "../utils/helper";
 import { type GraphqlParserFactory } from "./parser";
-type AllPossibleObject = "object" | "inputObject" | "whereInputObject" | "connectionObject" | "pointerInputObject" | "relationInputObject" | "updateInputObject" | "createInputObject" | "orderEnumType";
+type AllPossibleObject = "object" | "inputObject" | "whereInputObject" | "connectionObject" | "pointerInputObject" | "relationInputObject" | "relationWhereInputObject" | "updateInputObject" | "createInputObject" | "orderEnumType";
 export type AllObjects = Record<string, Partial<Record<AllPossibleObject, any>>>;
 export declare class GraphQLSchema {
 	private schemas;

package/dist/graphql/resolvers.d.ts

@@ -2,6 +2,7 @@ import type { SelectionSetNode, FragmentDefinitionNode } from "graphql";
 import type { WabeContext } from "../server/interface";
 export declare const extractFieldsFromSetNode: (selectionSet: SelectionSetNode, className: string, fragments?: Record<string, FragmentDefinitionNode>, options?: {
 	ignoreClassField?: boolean;
+	variables?: Record<string, any>;
 }) => Record<string, any>;
 export declare const getFieldsOfClassName: ({ fields, className, context }: {
 	fields: string[];

package/dist/hooks/protected.d.ts

@@ -1,3 +1,6 @@
+import type { SchemaClassWithProtectedFields } from "../schema/Schema";
+import type { WabeContext } from "../server/interface";
+export declare const canUserReadField: (schemaClass: SchemaClassWithProtectedFields, fieldName: string, context: Pick<WabeContext<any>, "isRoot" | "user">) => boolean;
 export declare const defaultCheckProtectedOnBeforeRead: unknown;
 export declare const defaultCheckProtectedOnBeforeUpdate: unknown;
 export declare const defaultCheckProtectedOnBeforeCreate: unknown;

package/dist/hooks/virtualFields.d.ts

@@ -0,0 +1,3 @@
+import type { Hook } from ".";
+import type { DevWabeTypes } from "../utils/helper";
+export declare const defaultVirtualFieldsAfterRead: Hook<DevWabeTypes, any>["callback"];