wabe 0.6.3 → 0.6.5

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

@@ -0,0 +1,263 @@
+import type { WabeContext } from "../../server/interface";
+import type { WabeTypes } from "../../server";
+type IsScalar<T> = T extends string | number | boolean | Date ? true : false;
+type IsArray<T> = T extends Array<any> ? true : false;
+type IsObject<
+	T,
+	K extends WabeTypes
+> = T extends object ? T extends K["types"][keyof K["types"]] ? false : true : false;
+type ExtractType<
+	T extends WabeTypes,
+	ClassName extends keyof T["types"],
+	FieldName extends keyof T["types"][ClassName]
+> = T["types"][ClassName][FieldName];
+type ExtractWhereType<
+	T extends WabeTypes,
+	ClassName extends keyof T["where"],
+	FieldName extends keyof T["where"][ClassName]
+> = T["where"][ClassName][FieldName];
+type WhereScalar<T> = {
+	equalTo?: T
+	notEqualTo?: T
+	greaterThan?: T
+	lessThan?: T
+	greaterThanOrEqualTo?: T
+	lessThanOrEqualTo?: T
+	in?: T[]
+	notIn?: T[]
+	contains?: T
+	notContains?: T
+};
+type WhereObject<T> = { [P in keyof T] : IsScalar<T[P]> extends false ? WhereObject<Partial<T[P]>> : WhereScalar<T[P]> };
+type WhereAggregation<
+	T extends WabeTypes,
+	K = keyof T["where"]
+> = { [P in keyof T["where"][K]] : IsScalar<ExtractWhereType<T, K, P>> extends false ? WhereObject<Partial<ExtractWhereType<T, K, P>>> : WhereScalar<ExtractWhereType<T, K, P>> };
+type WhereConditional<
+	T extends WabeTypes,
+	K = keyof T["where"]
+> = {
+	OR?: Array<WhereType<T, K>>
+	AND?: Array<WhereType<T, K>>
+};
+export type WhereType<
+	T extends WabeTypes,
+	K = keyof T["where"]
+> = Partial<WhereAggregation<T, K>> & WhereConditional<T, K>;
+type SelectObject<
+	T,
+	K extends WabeTypes,
+	Depth extends number = 3
+> = { [P in keyof T] : IsScalar<T[P]> extends true ? boolean : IsArray<T[P]> extends true ? T[P] extends Array<infer Item> ? (Depth extends 0 ? boolean : SelectObject<Partial<Item>, K, Decrement<Depth>>) | boolean : boolean : IsObject<[P], K> extends true ? (Depth extends 0 ? boolean : SelectObject<Partial<T[P]>, K, Decrement<Depth>>) | boolean : boolean };
+type Decrement<N extends number> = [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10][N];
+export type SelectType<
+	T extends WabeTypes,
+	K extends keyof T["types"],
+	U extends keyof T["types"][K],
+	Depth extends number = 3
+> = Partial<{ [P in U] : IsScalar<ExtractType<T, K, P>> extends true ? boolean : IsArray<ExtractType<T, K, P>> extends true ? ExtractType<T, K, P> extends Array<infer Item> ? (Depth extends 0 ? boolean : SelectObject<Partial<Item>, T, Decrement<Depth>>) | boolean : boolean : ExtractType<T, K, P> extends object ? (Depth extends 0 ? boolean : SelectObject<Partial<ExtractType<T, K, P>>, T, Decrement<Depth>>) | boolean : boolean }>;
+export type OrderType<
+	T extends WabeTypes,
+	K extends keyof T["types"],
+	U extends keyof T["types"][K]
+> = Record<U, "ASC" | "DESC">;
+export type OutputType<
+	T extends WabeTypes,
+	K extends keyof T["types"],
+	U extends keyof T["types"][K]
+> = (Pick<T["types"][K], U> & {
+	id: string
+}) | null;
+export interface AdapterOptions {
+	databaseUrl: string;
+	databaseName: string;
+}
+export type MutationData<
+	T extends WabeTypes,
+	K extends keyof T["types"],
+	U extends keyof T["types"][K]
+> = Record<U, any>;
+export interface CountOptions<
+	T extends WabeTypes,
+	K extends keyof T["types"]
+> {
+	className: K;
+	where?: WhereType<T, K>;
+	context: WabeContext<any>;
+}
+export interface GetObjectOptions<
+	T extends WabeTypes,
+	K extends keyof T["types"],
+	U extends keyof T["types"][K]
+> {
+	className: K;
+	id: string;
+	where?: WhereType<T, K>;
+	context: WabeContext<any>;
+	skipHooks?: boolean;
+	select?: SelectType<T, K, U>;
+	isGraphQLCall?: boolean;
+}
+export interface GetObjectsOptions<
+	T extends WabeTypes,
+	K extends keyof T["types"],
+	U extends keyof T["types"][K],
+	W extends keyof T["types"][K]
+> {
+	className: K;
+	where?: WhereType<T, K>;
+	order?: OrderType<T, K, U>;
+	offset?: number;
+	first?: number;
+	context: WabeContext<any>;
+	skipHooks?: boolean;
+	select?: SelectType<T, K, W>;
+	isGraphQLCall?: boolean;
+}
+export interface CreateObjectOptions<
+	T extends WabeTypes,
+	K extends keyof T["types"],
+	U extends keyof T["types"][K],
+	W extends keyof T["types"][K]
+> {
+	className: K;
+	data: MutationData<T, K, U>;
+	context: WabeContext<any>;
+	select?: SelectType<T, K, W>;
+	isGraphQLCall?: boolean;
+}
+export interface CreateObjectsOptions<
+	T extends WabeTypes,
+	K extends keyof T["types"],
+	U extends keyof T["types"][K],
+	W extends keyof T["types"][K],
+	X extends keyof T["types"][K]
+> {
+	className: K;
+	data: Array<MutationData<T, K, U>>;
+	offset?: number;
+	first?: number;
+	order?: OrderType<T, U, X>;
+	context: WabeContext<any>;
+	select?: SelectType<T, K, W>;
+	isGraphQLCall?: boolean;
+}
+export interface UpdateObjectOptions<
+	T extends WabeTypes,
+	K extends keyof T["types"],
+	U extends keyof T["types"][K],
+	W extends keyof T["types"][K]
+> {
+	className: K;
+	id: string;
+	where?: WhereType<T, K>;
+	data: MutationData<T, K, U>;
+	context: WabeContext<any>;
+	skipHooks?: boolean;
+	select?: SelectType<T, K, W>;
+	isGraphQLCall?: boolean;
+}
+export interface UpdateObjectsOptions<
+	T extends WabeTypes,
+	K extends keyof T["types"],
+	U extends keyof T["types"][K],
+	W extends keyof T["types"][K],
+	X extends keyof T["types"][K]
+> {
+	className: K;
+	where: WhereType<T, K>;
+	order?: OrderType<T, K, X>;
+	data: MutationData<T, K, U>;
+	offset?: number;
+	first?: number;
+	context: WabeContext<any>;
+	skipHooks?: boolean;
+	select?: SelectType<T, K, W>;
+	isGraphQLCall?: boolean;
+}
+export interface DeleteObjectOptions<
+	T extends WabeTypes,
+	K extends keyof T["types"],
+	U extends keyof T["types"][K]
+> {
+	className: K;
+	id: string;
+	where?: WhereType<T, K>;
+	context: WabeContext<any>;
+	select?: SelectType<T, K, U>;
+	isGraphQLCall?: boolean;
+}
+export interface DeleteObjectsOptions<
+	T extends WabeTypes,
+	K extends keyof T["types"],
+	U extends keyof T["types"][K],
+	W extends keyof T["types"][K]
+> {
+	className: K;
+	where: WhereType<T, K>;
+	order?: OrderType<T, K, U>;
+	offset?: number;
+	first?: number;
+	context: WabeContext<any>;
+	select?: SelectType<T, K, W>;
+	isGraphQLCall?: boolean;
+}
+export interface DatabaseAdapter<T extends WabeTypes> {
+	connect(): Promise<any>;
+	close(): Promise<any>;
+	createClassIfNotExist(className: string, context: WabeContext<any>): Promise<any>;
+	clearDatabase(): Promise<void>;
+	count<
+		T extends WabeTypes,
+		K extends keyof T["types"]
+	>(params: CountOptions<T, K>): Promise<number>;
+	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>): Promise<{
+		id: string
+	}>;
+	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>): Promise<Array<{
+		id: string
+	}>>;
+	updateObject<
+		K extends keyof T["types"],
+		U extends keyof T["types"][K],
+		W extends keyof T["types"][K]
+	>(params: UpdateObjectOptions<T, K, U, W>): Promise<{
+		id: string
+	}>;
+	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>): Promise<Array<{
+		id: string
+	}>>;
+	deleteObject<
+		K extends keyof T["types"],
+		U extends keyof T["types"][K]
+	>(params: DeleteObjectOptions<T, K, U>): Promise<void>;
+	deleteObjects<
+		K extends keyof T["types"],
+		U extends keyof T["types"][K],
+		W extends keyof T["types"][K]
+	>(params: DeleteObjectsOptions<T, K, U, W>): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,2 @@
+export * from "./MongoAdapter";
+export * from "./adaptersInterface";

package/dist/database/controllers/DatabaseController.d.ts

@@ -0,0 +1,90 @@
+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";
+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
+	}): {
+		pointers: Record<string, {
+			className: string
+			select: Select
+		}>
+		selectWithoutPointers: Select
+	};
+	_isRelationField({ pointerField, currentClassName, context, originClassName }: {
+		pointerField: string
+		originClassName: string
+		context: WabeContext<T>
+		currentClassName?: string
+	});
+	_isPointerField({ pointerField, currentClassName, context, originClassName }: {
+		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
+		pointers: Record<string, {
+			className: string
+			select: Select
+		}>
+		context: WabeContext<any>
+		object: Record<string, any>
+		isGraphQLCall?: boolean
+	});
+	connect(): Promise<any>;
+	close(): Promise<any>;
+	createClassIfNotExist(className: string, context: WabeContext<T>): Promise<any>;
+	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>>;
+	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>[]>;
+	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>>;
+	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>[]>;
+	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>>;
+	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>[]>;
+	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>>;
+	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>[]>;
+}
+export {};

package/dist/database/controllers/index.d.ts

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

package/dist/database/index.d.ts

@@ -0,0 +1,10 @@
+export declare enum DatabaseEnum {
+	Mongo = "mongo",
+}
+export interface DatabaseConfig {
+	type: DatabaseEnum;
+	url: string;
+	name: string;
+}
+export * from "./adapters";
+export * from "./controllers";

package/dist/email/DevAdapter.d.ts

@@ -0,0 +1,4 @@
+import type { EmailAdapter } from "./interface";
+export declare class EmailDevAdapter implements EmailAdapter {
+	send();
+}

package/dist/email/EmailController.d.ts

@@ -0,0 +1,6 @@
+import type { EmailAdapter, EmailSendOptions } from "./interface";
+export declare class EmailController implements EmailAdapter {
+	adapter: EmailAdapter;
+	constructor(adapter: EmailAdapter);
+	send(options: EmailSendOptions);
+}

package/dist/email/index.d.ts

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

package/dist/email/interface.d.ts

@@ -0,0 +1,35 @@
+export type HtmlTemplates = {
+	sendOTPCode: {
+		fn: (options: {
+			otp: string
+		}) => string | Promise<string>
+		subject: string
+	}
+};
+export interface EmailSendOptions {
+	from: string;
+	to: Array<string>;
+	subject: string;
+	node?: React.ReactNode;
+	html?: string;
+	text?: string;
+}
+export interface EmailAdapter {
+	/**
+	* Send an email using the provided adapter
+	* @param options Mail options (expeditor, recipient, subject ...)
+	* @return The id of the email sended, throw an error if something wrong
+	*/
+	send(options: EmailSendOptions): Promise<string>;
+}
+/**
+* Configuration for the email in Wabe
+* @property adapter The adapter to use to send emails
+* @property mainEmail The email to use as sender for emails sent by Wabe
+* @property templates The html templates to use for a specific email. If not provided, Wabe will use the default templates
+*/
+export interface EmailConfig {
+	adapter: EmailAdapter;
+	mainEmail?: string;
+	htmlTemplates?: HtmlTemplates;
+}

package/dist/email/templates/sendOtpCode.d.ts

@@ -0,0 +1 @@
+export declare const sendOtpCodeTemplate: (otp: string) => string;

package/dist/files/FileController.d.ts

@@ -0,0 +1,10 @@
+import type { Wabe } from "../server";
+import type { FileAdapter, ReadFileOptions } from "./interface";
+export declare class FileController implements FileAdapter {
+	adapter: FileAdapter;
+	private wabe;
+	constructor(adapter: FileAdapter, wabe: Wabe<any>);
+	uploadFile(file: File | Blob);
+	readFile(fileName: string, options?: ReadFileOptions);
+	deleteFile(fileName: string);
+}

package/dist/files/FileDevAdapter.d.ts

@@ -0,0 +1,8 @@
+import type { FileAdapter, ReadFileOptions } from ".";
+export declare class FileDevAdapter implements FileAdapter {
+	private basePath;
+	private rootPath;
+	uploadFile(file: File | Blob): Promise<void>;
+	readFile(fileName: string, options?: ReadFileOptions): Promise<string | null>;
+	deleteFile(fileName: string): Promise<void>;
+}

package/dist/files/hookDeleteFile.d.ts

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

package/dist/files/hookReadFile.d.ts

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

package/dist/files/hookUploadFile.d.ts

@@ -0,0 +1,2 @@
+export declare const defaultBeforeCreateUpload: unknown;
+export declare const defaultBeforeUpdateUpload: unknown;

package/dist/files/index.d.ts

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

package/dist/files/interface.d.ts

@@ -0,0 +1,30 @@
+/**
+* The file config contains the adapter to use to upload file
+* @param adapter: FileAdapter
+* @param urlCacheInSeconds: number Number of seconds to cache the url, equal to the number of seconds the url will be valid
+* @param devDirectory: string The directory where the files will be uploaded
+*/
+export interface FileConfig {
+	adapter: FileAdapter;
+	urlCacheInSeconds?: number;
+	devDirectory?: string;
+}
+export interface ReadFileOptions {
+	urlExpiresIn?: number;
+	port?: number;
+}
+export interface FileAdapter {
+	/**
+	* Upload a file and returns the url of the file
+	* @param file: File
+	*/
+	uploadFile(file: File | Blob): Promise<void>;
+	/**
+	* Read a file and returns the url of the file
+	* @param fileName: string
+	* @param urlExpiresIn: number Number of seconds to expire the url
+	* @returns The url of file or null if the file doesn't exist
+	*/
+	readFile(fileName: string, options?: ReadFileOptions): Promise<string | null> | string | null;
+	deleteFile(fileName: string): Promise<void>;
+}

package/dist/graphql/GraphQLSchema.d.ts

@@ -0,0 +1,75 @@
+import { GraphQLEnumType, type GraphQLFieldConfig, GraphQLInputObjectType, GraphQLObjectType, type GraphQLOutputType } from "graphql";
+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";
+export type AllObjects = Record<string, Partial<Record<AllPossibleObject, any>>>;
+export declare class GraphQLSchema {
+	private schemas;
+	private allObjects;
+	constructor(schemas: Schema<any>);
+	createSchema(): {};
+	createFileObjects(): unknown;
+	createScalars();
+	createOrderEnumType(wabeClass: ClassInterface<DevWabeTypes>);
+	createEnums();
+	createObject({ wabeClass, graphqlParser }: {
+		wabeClass: ClassInterface<DevWabeTypes>
+		graphqlParser: GraphqlParserFactory<DevWabeTypes>
+	});
+	createPointerInputObject({ wabeClass, inputCreateFields }: {
+		wabeClass: ClassInterface<DevWabeTypes>
+		inputCreateFields: GraphQLInputObjectType
+	});
+	createRelationInputObject({ wabeClass, inputCreateFields }: {
+		wabeClass: ClassInterface<DevWabeTypes>
+		inputCreateFields: GraphQLInputObjectType
+	});
+	createInputObject({ wabeClass, graphqlParser }: {
+		wabeClass: ClassInterface<DevWabeTypes>
+		graphqlParser: GraphqlParserFactory<DevWabeTypes>
+	});
+	createCreateInputObject({ wabeClass, graphqlParser }: {
+		wabeClass: ClassInterface<DevWabeTypes>
+		graphqlParser: GraphqlParserFactory<DevWabeTypes>
+	});
+	createUpdateInputObject({ wabeClass, graphqlParser }: {
+		wabeClass: ClassInterface<DevWabeTypes>
+		graphqlParser: GraphqlParserFactory<DevWabeTypes>
+	});
+	createWhereInputObject({ wabeClass, graphqlParser }: {
+		wabeClass: ClassInterface<DevWabeTypes>
+		graphqlParser: GraphqlParserFactory<DevWabeTypes>
+	});
+	createConnectionObject({ object, wabeClass }: {
+		object: GraphQLObjectType
+		wabeClass: ClassInterface<DevWabeTypes>
+	});
+	createCompleteObject(graphqlParser: GraphqlParserFactory<DevWabeTypes>, wabeClass: ClassInterface<DevWabeTypes>);
+	_getGraphQLOutputType(currentQueryOrMutation: QueryResolver<DevWabeTypes> | MutationResolver<DevWabeTypes>, graphqlParser: GraphqlParserFactory<DevWabeTypes>, currentArgs: SchemaFields<DevWabeTypes>): GraphQLOutputType | undefined;
+	createCustomMutations({ resolvers, graphqlParser }: {
+		resolvers: Record<string, MutationResolver<DevWabeTypes>>
+		graphqlParser: GraphqlParserFactory<DevWabeTypes>
+	});
+	createCustomQueries({ resolvers, graphqlParser }: {
+		resolvers: Record<string, QueryResolver<DevWabeTypes>>
+		graphqlParser: GraphqlParserFactory<DevWabeTypes>
+	});
+	createDefaultQueries({ className, whereInputType, object, connectionObject, orderEnumType }: {
+		className: string
+		whereInputType: GraphQLInputObjectType
+		object: GraphQLObjectType
+		connectionObject: GraphQLObjectType
+		orderEnumType: GraphQLEnumType
+	}): Record<string, GraphQLFieldConfig<any, any, any>>;
+	createDefaultMutations({ className, object, defaultUpdateInputType, defaultCreateInputType, whereInputType, connectionObject, orderEnumType }: {
+		className: string
+		defaultUpdateInputType: GraphQLInputObjectType
+		defaultCreateInputType: GraphQLInputObjectType
+		whereInputType: GraphQLInputObjectType
+		object: GraphQLObjectType
+		connectionObject: GraphQLObjectType
+		orderEnumType: GraphQLEnumType
+	}): Record<string, GraphQLFieldConfig<any, any, any>>;
+}
+export {};

package/dist/graphql/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./GraphQLSchema";

package/dist/graphql/parser.d.ts

@@ -0,0 +1,38 @@
+import { type GraphQLEnumType, GraphQLInputObjectType, type GraphQLScalarType } from "graphql";
+import { type AllObjects } from "../graphql";
+import type { ClassInterface, SchemaFields, WabePrimaryTypes } from "../schema";
+import type { WabeTypes } from "../server";
+import type { DevWabeTypes } from "../utils/helper";
+type GraphqlObjectType = "Object" | "InputObject" | "CreateFieldsInput" | "UpdateFieldsInput" | "WhereInputObject";
+type ParseObjectOptions = {
+	required?: boolean
+	description?: string
+	objectToParse: ClassInterface<any>
+	nameOfTheObject: string
+};
+export declare const templateScalarType: Record<WabePrimaryTypes, GraphQLScalarType>;
+export declare const templateWhereInput: Record<WabePrimaryTypes | "Array", GraphQLInputObjectType>;
+interface GraphqlParserFactoryOptions {
+	graphqlObjectType: GraphqlObjectType;
+	allObjects: AllObjects;
+	schemaFields: SchemaFields<DevWabeTypes>;
+}
+interface GraphqlParserConstructorOptions {
+	scalars: GraphQLScalarType[];
+	enums: GraphQLEnumType[];
+}
+export type GraphqlParserFactory<T extends WabeTypes> = (options: GraphqlParserFactoryOptions) => {
+	_parseWabeObject(options: ParseObjectOptions): any
+	_parseWabeWhereInputObject(options: ParseObjectOptions): any
+	_parseWabeInputObject(options: ParseObjectOptions): any
+	_parseWabeUpdateInputObject(options: ParseObjectOptions): any
+	getGraphqlType(options: {
+		type: WabePrimaryTypes | "Array" | T["enums"] | T["scalars"]
+		typeValue?: WabePrimaryTypes
+		isWhereType?: boolean
+	}): any
+	getGraphqlFields(nameOfTheObject: string): any
+};
+export type GraphqlParserConstructor = <T extends WabeTypes>(options: GraphqlParserConstructorOptions) => GraphqlParserFactory<T>;
+export declare const GraphqlParser: GraphqlParserConstructor;
+export {};

package/dist/graphql/pointerAndRelationFunction.d.ts

@@ -0,0 +1,20 @@
+type CreateAndLink = any;
+type Link = string;
+type Unlink = boolean;
+type Add = Array<string>;
+type Remove = Array<string>;
+type CreateAndAdd = Array<any>;
+export type TypeOfExecution = "create" | "update" | "updateMany";
+export type InputFields = Record<string, {
+	createAndLink?: CreateAndLink
+	link?: Link
+	unlink?: Unlink
+	add?: Add
+	remove?: Remove
+	createAndAdd?: CreateAndAdd
+} | string>;
+export declare const createAndLink: unknown;
+export declare const createAndAdd: unknown;
+export declare const add: unknown;
+export declare const remove: unknown;
+export {};

package/dist/graphql/resolvers.d.ts

@@ -0,0 +1,20 @@
+import type { SelectionSetNode } from "graphql";
+import type { WabeContext } from "../server/interface";
+export declare const extractFieldsFromSetNode: (selectionSet: SelectionSetNode, className: string) => Record<string, any>;
+export declare const getFieldsOfClassName: ({ fields, className, context }: {
+	fields: string[]
+	className: string
+	context: WabeContext<any>
+}) => {
+	classFields: string[]
+	othersFields: string[]
+};
+export declare const executeRelationOnFields: unknown;
+export declare const queryForOneObject: unknown;
+export declare const queryForMultipleObject: unknown;
+export declare const mutationToCreateObject: unknown;
+export declare const mutationToCreateMultipleObjects: unknown;
+export declare const mutationToUpdateObject: unknown;
+export declare const mutationToUpdateMultipleObjects: unknown;
+export declare const mutationToDeleteObject: unknown;
+export declare const mutationToDeleteMultipleObjects: unknown;