wabe 0.6.7 → 0.6.9

package/dist/schema/Schema.d.ts

@@ -1,101 +1,103 @@
 import type { WabeConfig, WabeTypes } from "../server";
 import type { HookObject } from "../hooks/HookObject";
-export type WabePrimaryTypes = "String" | "Int" | "Float" | "Boolean" | "Email" | "Phone" | "Date" | "File";
+export type WabePrimaryTypes = "String" | "Int" | "Float" | "Boolean" | "Email" | "Phone" | "Date" | "File" | "Hash";
 export type WabeCustomTypes = "Array" | "Object";
 export type WabeRelationTypes = "Pointer" | "Relation";
-type WabeFieldTypes = WabeCustomTypes | WabePrimaryTypes | WabeRelationTypes;
+export type WabeFieldTypes = WabeCustomTypes | WabePrimaryTypes | WabeRelationTypes;
 export type WabeObject<T extends WabeTypes> = {
-	name: string
-	fields: SchemaFields<T>
-	description?: string
-	required?: boolean
+	name: string;
+	fields: SchemaFields<T>;
+	description?: string;
+	required?: boolean;
 };
 type FieldBase<T extends WabeTypes> = {
-	required?: boolean
-	description?: string
+	required?: boolean;
+	description?: string;
 	protected?: {
-		authorizedRoles: Array<T["enums"]["RoleEnum"] | "rootOnly">
-		protectedOperations: Array<"create" | "read" | "update">
-	}
+		authorizedRoles: Array<T["enums"]["RoleEnum"] | "rootOnly">;
+		protectedOperations: Array<"create" | "read" | "update">;
+	};
 };
 type TypeFieldBase<
 	U,
 	K extends WabeFieldTypes
 > = {
-	type: K
-	defaultValue?: U
+	type: K;
+	defaultValue?: U;
 };
 type TypeFieldArray<T extends WabeTypes> = {
-	type: "Array"
-	requiredValue?: boolean
-	defaultValue?: any[]
+	type: "Array";
+	requiredValue?: boolean;
+	defaultValue?: any[];
 } & ({
-	typeValue: WabePrimaryTypes
+	// For the moment we only keep object and not array because we don't
+	// support array of array
+	typeValue: WabePrimaryTypes;
 } | {
-	typeValue: "Object"
-	object: WabeObject<T>
+	typeValue: "Object";
+	object: WabeObject<T>;
 });
 type TypeFieldObject<T extends WabeTypes> = {
-	type: "Object"
-	object: WabeObject<T>
-	defaultValue?: any
+	type: "Object";
+	object: WabeObject<T>;
+	defaultValue?: any;
 };
 type TypeFieldPointer<T extends WabeTypes> = {
-	type: "Pointer"
-	class: keyof T["types"]
+	type: "Pointer";
+	class: keyof T["types"];
 };
 type TypeFieldRelation<T extends WabeTypes> = {
-	type: "Relation"
-	class: keyof T["types"]
+	type: "Relation";
+	class: keyof T["types"];
 };
 type TypeFieldFile = {
-	type: "File"
+	type: "File";
 };
 type TypeFieldCustomScalars<T extends WabeTypes> = {
-	type: T["scalars"]
-	required?: boolean
-	defaultValue?: any
+	type: T["scalars"];
+	required?: boolean;
+	defaultValue?: any;
 };
 type TypeFieldCustomEnums<T extends WabeTypes> = {
-	type: keyof T["enums"]
-	defaultValue?: any
+	type: keyof T["enums"];
+	defaultValue?: any;
 };
-export type TypeField<T extends WabeTypes> = (TypeFieldBase<string, "String"> | TypeFieldBase<number, "Int"> | TypeFieldBase<number, "Float"> | TypeFieldBase<boolean, "Boolean"> | TypeFieldBase<Date, "Date"> | TypeFieldBase<string, "Email"> | TypeFieldBase<string, "Phone"> | TypeFieldArray<T> | TypeFieldObject<T> | TypeFieldPointer<T> | TypeFieldRelation<T> | TypeFieldFile | TypeFieldCustomScalars<T> | TypeFieldCustomEnums<T>) & FieldBase<T>;
+export type TypeField<T extends WabeTypes> = (TypeFieldBase<string, "String"> | TypeFieldBase<number, "Int"> | TypeFieldBase<number, "Float"> | TypeFieldBase<boolean, "Boolean"> | TypeFieldBase<Date, "Date"> | TypeFieldBase<string, "Email"> | TypeFieldBase<string, "Phone"> | TypeFieldBase<string, "Hash"> | TypeFieldArray<T> | TypeFieldObject<T> | TypeFieldPointer<T> | TypeFieldRelation<T> | TypeFieldFile | TypeFieldCustomScalars<T> | TypeFieldCustomEnums<T>) & FieldBase<T>;
 export type SchemaFields<T extends WabeTypes> = Record<string, TypeField<T>>;
 export type ResolverType<T extends WabeTypes> = {
-	required?: boolean
-	description?: string
-	resolve: (...args: any) => any
+	required?: boolean;
+	description?: string;
+	resolve: (...args: any) => any;
 } & ({
-	type: WabePrimaryTypes | T["enums"] | T["scalars"]
+	type: WabePrimaryTypes | T["enums"] | T["scalars"];
 } | {
-	type: "Object"
-	outputObject: ClassInterface<T>
+	type: "Object";
+	outputObject: ClassInterface<T>;
 } | {
-	type: "Array"
-	typeValue: WabePrimaryTypes
-	typeValueRequired?: boolean
+	type: "Array";
+	typeValue: WabePrimaryTypes;
+	typeValueRequired?: boolean;
 } | {
-	type: "Array"
-	typeValue: "Object"
-	outputObject: ClassInterface<T>
-	typeValueRequired?: boolean
+	type: "Array";
+	typeValue: "Object";
+	outputObject: ClassInterface<T>;
+	typeValueRequired?: boolean;
 });
 export type QueryResolver<T extends WabeTypes> = {
-	args?: SchemaFields<T>
+	args?: SchemaFields<T>;
 } & ResolverType<T>;
 export type MutationResolver<T extends WabeTypes> = {
 	args?: {
-		input: SchemaFields<T>
-	}
+		input: SchemaFields<T>;
+	};
 } & ResolverType<T>;
 export type TypeResolver<T extends WabeTypes> = {
 	queries?: {
-		[key: string]: QueryResolver<T>
-	}
+		[key: string]: QueryResolver<T>;
+	};
 	mutations?: {
-		[key: string]: MutationResolver<T>
-	}
+		[key: string]: MutationResolver<T>;
+	};
 };
 export type PermissionsOperations = "create" | "read" | "update" | "delete";
 export interface PermissionProperties<T extends WabeTypes> {
@@ -112,13 +114,13 @@ export interface PermissionProperties<T extends WabeTypes> {
 */
 export type ACLProperties = (hookObject: HookObject<any, any>) => void | Promise<void>;
 export type ClassPermissions<T extends WabeTypes> = Partial<Record<PermissionsOperations, PermissionProperties<T>> & {
-	acl: ACLProperties
+	acl: ACLProperties;
 }>;
 export type SearchableFields = Array<string>;
 export type ClassIndexes = Array<{
-	field: string
-	order: "ASC" | "DESC"
-	unique?: boolean
+	field: string;
+	order: "ASC" | "DESC";
+	unique?: boolean;
 }>;
 export interface ClassInterface<T extends WabeTypes> {
 	name: string;

package/dist/schema/defaultResolvers.d.ts

@@ -1,7 +1,7 @@
 import type { MutationResolver, QueryResolver } from "./Schema";
 export declare const defaultQueries: {
-	[key: string]: QueryResolver<any>
+	[key: string]: QueryResolver<any>;
 };
 export declare const defaultMutations: {
-	[key: string]: MutationResolver<any>
+	[key: string]: MutationResolver<any>;
 };

package/dist/server/index.d.ts

@@ -1,5 +1,5 @@
 import type { DatabaseConfig } from "../database";
-import { DatabaseController } from "../database/controllers/DatabaseController";
+import { DatabaseController } from "../database/DatabaseController";
 import { type SchemaInterface } from "../schema/Schema";
 import { GraphQLSchema } from "graphql";
 import type { AuthenticationConfig } from "../authentication/interface";
@@ -9,18 +9,16 @@ import { generateCodegen } from "./generateCodegen";
 import { Wobe } from "wobe";
 import type { Context, CorsOptions, RateLimitOptions } from "wobe";
 import type { WabeContext } from "./interface";
-import type { FileConfig } from "../files";
 import type { EmailConfig } from "../email";
 import { EmailController } from "../email/EmailController";
-import type { PaymentConfig } from "../payment/interface";
-import { PaymentController } from "../payment/PaymentController";
 import type { AIConfig } from "../ai";
-import { FileController } from "../files/FileController";
+import { FileController } from "../file/FileController";
 import type { CronConfig } from "../cron";
+import type { FileConfig } from "../file";
 type SecurityConfig = {
-	corsOptions?: CorsOptions
-	rateLimit?: RateLimitOptions
-	maskErrorMessage?: boolean
+	corsOptions?: CorsOptions;
+	rateLimit?: RateLimitOptions;
+	hideSensitiveErrorMessage?: boolean;
 };
 export * from "./interface";
 export * from "./routes";
@@ -31,43 +29,41 @@ export interface WabeConfig<T extends WabeTypes> {
 	security?: SecurityConfig;
 	schema?: SchemaInterface<T>;
 	graphqlSchema?: GraphQLSchema;
-	database: DatabaseConfig;
+	database: DatabaseConfig<T>;
 	codegen?: {
-		enabled: true
-		path: string
+		enabled: true;
+		path: string;
 	} | {
-		enabled?: false
+		enabled?: false;
 	};
 	authentication?: AuthenticationConfig<T>;
 	routes?: WabeRoute[];
 	rootKey: string;
 	hooks?: Hook<T, any>[];
 	email?: EmailConfig;
-	payment?: PaymentConfig;
 	ai?: AIConfig;
-	file?: FileConfig;
+	file?: FileConfig<T>;
 	crons?: CronConfig<T>;
 }
 export type WabeTypes = {
-	types: Record<any, any>
-	where: Record<any, any>
-	scalars: string
-	enums: Record<any, any>
+	types: Record<any, any>;
+	where: Record<any, any>;
+	scalars: string;
+	enums: Record<any, any>;
 };
 export type WobeCustomContext<T extends WabeTypes> = Context & {
-	wabe: WabeContext<T>
+	wabe: WabeContext<T>;
 };
 type WabeControllers<T extends WabeTypes> = {
-	database: DatabaseController<T>
-	email?: EmailController
-	payment?: PaymentController
-	file?: FileController
+	database: DatabaseController<T>;
+	email?: EmailController;
+	file?: FileController;
 };
 export declare class Wabe<T extends WabeTypes> {
 	server: Wobe<WobeCustomContext<T>>;
 	config: WabeConfig<T>;
 	controllers: WabeControllers<T>;
-	constructor({ isProduction, port, hostname, security, schema, database, authentication, rootKey, codegen, hooks, file, email, payment, routes, crons }: WabeConfig<T>);
+	constructor({ isProduction, port, hostname, security, schema, database, authentication, rootKey, codegen, hooks, file, email, routes, crons }: WabeConfig<T>);
 	loadCrons();
 	loadRoleEnum();
 	loadAuthenticationMethods();

package/dist/server/interface.d.ts

@@ -6,4 +6,5 @@ export interface WabeContext<T extends WabeTypes> {
 	sessionId?: string | null;
 	isRoot: boolean;
 	wabe: Wabe<T>;
+	isGraphQLCall?: boolean;
 }

package/dist/server/routes/authHandler.d.ts

@@ -1,2 +1,13 @@
+/*
+- Generate code verifier (back)
+- Sent post request to a route on back with code verifier in url (back)
+- Generate code challenge (back)
+- Redirect the user to google auth page with code challenge (back -> front)
+- User sign in with google (front)
+- The user is redirected to the route with the code (front -> back)
+- Get the code from the url (back)
+- Validate and sign in with google provider (back)
+*/
+// https://www.rfc-editor.org/rfc/rfc7636#section-4.4 not precise the storage of codeVerifier
 export declare const oauthHandlerCallback: unknown;
 export declare const authHandler: unknown;

package/dist/utils/crypto.d.ts

@@ -0,0 +1,11 @@
+/*
+* Hash a string with Argon2id and PHC format
+* @return : Returns the PHC format of the hashed text
+*/
+export declare const hashArgon2: unknown;
+/*
+* Verify if a hash matchs with a string
+* @return : Returns true if the password matchs with the hash, false otherwise
+*/
+export declare const verifyArgon2: unknown;
+export declare const isArgon2Hash: (value: string) => boolean;

package/dist/utils/export.d.ts

@@ -1,2 +1,4 @@
 import type { WabeContext } from "../server/interface";
 export declare const contextWithRoot: (context: WabeContext<any>) => WabeContext<any>;
+export declare const notEmpty: <T>(value: T | null | undefined) => value is T;
+export * from "./crypto";

package/dist/utils/helper.d.ts

@@ -1,6 +1,6 @@
 import { GraphQLClient } from "graphql-request";
 import { type WabeSchemaWhereTypes, type WabeSchemaEnums, type WabeSchemaScalars, type WabeSchemaTypes } from "../../generated/wabe";
-import { Wabe, type WabeTypes } from "../server";
+import type { Wabe, WabeTypes } from "../server";
 export interface DevWabeTypes extends WabeTypes {
 	types: WabeSchemaTypes;
 	scalars: WabeSchemaScalars;
@@ -8,14 +8,11 @@ export interface DevWabeTypes extends WabeTypes {
 	where: WabeSchemaWhereTypes;
 }
 export declare const firstLetterUpperCase: (str: string) => string;
-export declare const notEmpty: <T>(value: T | null | undefined) => value is T;
 export declare const getGraphqlClient: (port: number) => GraphQLClient;
 export declare const getAnonymousClient: (port: number) => GraphQLClient;
 export declare const getUserClient: (port: number, accessToken: string) => GraphQLClient;
 export declare const getAdminUserClient: (port: number, wabe: Wabe<DevWabeTypes>, { email, password }: {
-	email: string
-	password: string
+	email: string;
+	password: string;
 }) => Promise<GraphQLClient>;
-export declare const setupTests: unknown;
-export declare const closeTests: unknown;
 export declare const createUserAndUpdateRole: unknown;

package/dist/utils/index.d.ts

@@ -1,17 +1,35 @@
 import type { ClassInterface } from "../schema";
-import type { WabeTypes, WabeConfig } from "../server";
+import type { WabeTypes, WabeConfig, WabeContext } from "../server";
+export declare const contextWithoutGraphQLCall: (context: WabeContext<any>) => WabeContext<any>;
+type Base32Variant = "RFC3548" | "RFC4648" | "RFC4648-HEX" | "Crockford";
+interface Base32Options {
+	padding?: boolean;
+}
+/**
+* Convert supported input types to Uint8Array.
+*/
+export declare const toUint8Array: (data: string | ArrayBuffer | Uint8Array | Buffer) => Uint8Array;
+/**
+* Encode binary data to base32 using specified variant.
+* Base on https://github.com/LinusU/base32-encode/blob/master/index.js
+*/
+export declare const base32Encode: (data: string | ArrayBuffer | Uint8Array | Buffer, variant: Base32Variant, options?: Base32Options) => string;
+export declare const getNewObjectAfterUpdateNestedProperty: unknown;
+export declare const getNestedProperty: unknown;
 export declare const firstLetterInUpperCase: unknown;
 export declare const firstLetterInLowerCase: unknown;
 export declare const getClassFromClassName: <T extends WabeTypes>(className: string, config: WabeConfig<any>) => ClassInterface<T>;
+// TODO: Put this in wobe
 export declare const getCookieInRequestHeaders: unknown;
 /**
 * This apply the following transformations on string:
 * - lowercase
 * - normalize with NFD
 * - remove diacritics and accents characters
-* - replace matching abbreviation with long version (if disableAbbrevations is not set)
+* - replace matching abbreviation with long version (if disableAbbreviations is not set)
 * - replace 2 or more spaces by one
 * - replace all non alpha characters by a space
 * - trim
 */
 export declare const tokenize: unknown;
+export {};