wabe 0.6.11 → 0.6.13

package/src/graphql/parser.ts

@@ -1,542 +0,0 @@
-import {
-	GraphQLBoolean,
-	type GraphQLEnumType,
-	type GraphQLFieldConfig,
-	GraphQLFloat,
-	GraphQLInputObjectType,
-	GraphQLInt,
-	GraphQLList,
-	GraphQLNonNull,
-	GraphQLObjectType,
-	type GraphQLScalarType,
-	GraphQLString,
-} from 'graphql'
-import {
-	type AllObjects,
-	AnyWhereInput,
-	ArrayWhereInput,
-	BooleanWhereInput,
-	DateScalarType,
-	DateWhereInput,
-	EmailScalarType,
-	EmailWhereInput,
-	FileScalarType,
-	FileWhereInput,
-	FloatWhereInput,
-	IntWhereInput,
-	PhoneScalarType,
-	PhoneWhereInput,
-	StringWhereInput,
-} 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
-}
-
-type ParseObjectCallback = (options: ParseObjectOptions) => any
-
-export const templateScalarType: Record<WabePrimaryTypes, GraphQLScalarType> = {
-	String: GraphQLString,
-	Int: GraphQLInt,
-	Float: GraphQLFloat,
-	Boolean: GraphQLBoolean,
-	Date: DateScalarType,
-	Email: EmailScalarType,
-	File: FileScalarType,
-	Phone: PhoneScalarType,
-	Hash: GraphQLString,
-}
-
-export const templateWhereInput: Record<WabePrimaryTypes | 'Array', GraphQLInputObjectType> = {
-	String: StringWhereInput,
-	Int: IntWhereInput,
-	Float: FloatWhereInput,
-	Boolean: BooleanWhereInput,
-	Date: DateWhereInput,
-	Email: EmailWhereInput,
-	Phone: PhoneWhereInput,
-	Array: ArrayWhereInput,
-	File: FileWhereInput,
-	Hash: StringWhereInput,
-}
-
-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 const GraphqlParser: GraphqlParserConstructor =
-	({ scalars, enums }: GraphqlParserConstructorOptions) =>
-	({ graphqlObjectType, schemaFields, allObjects }: GraphqlParserFactoryOptions) => {
-		// Get graphql fields from a wabe object
-		const _getGraphqlFieldsFromAnObject = ({
-			objectToParse,
-			callBackForObjectType,
-			forceRequiredToFalse = false,
-			isWhereType = false,
-			nameOfTheObject,
-		}: {
-			objectToParse: ClassInterface<DevWabeTypes>
-			forceRequiredToFalse?: boolean
-			isWhereType?: boolean
-			callBackForObjectType: ParseObjectCallback
-			nameOfTheObject: string
-		}) => {
-			const fields = objectToParse.fields
-
-			const graphqlFields = Object.keys(fields).reduce(
-				(acc, key) => {
-					const currentField = fields[key]
-
-					const keyWithFirstLetterUppercase = `${key.charAt(0).toUpperCase()}${key.slice(1)}`
-
-					if (currentField?.type === 'Object') {
-						acc[key] = {
-							type: callBackForObjectType({
-								required: currentField.object.required,
-								description: currentField.description,
-								objectToParse: currentField.object,
-								nameOfTheObject: `${nameOfTheObject}${keyWithFirstLetterUppercase}`,
-							}),
-						}
-
-						return acc
-					}
-
-					if (currentField?.type === 'Array') {
-						if (currentField?.typeValue === 'Object') {
-							const objectList = new GraphQLList(
-								callBackForObjectType({
-									required: currentField.object.required,
-									description: currentField.description,
-									objectToParse: currentField.object,
-									nameOfTheObject: `${nameOfTheObject}${currentField.object.name}`,
-								}),
-							)
-
-							acc[key] = {
-								type: currentField.required ? new GraphQLNonNull(objectList) : objectList,
-							}
-						}
-
-						if (
-							currentField.typeValue &&
-							// @ts-expect-error
-							templateScalarType[currentField.typeValue]
-						) {
-							const graphqlType = getGraphqlType({
-								type: currentField.type,
-								// @ts-expect-error
-								typeValue: currentField.typeValue,
-								isWhereType,
-								requiredValue: currentField.requiredValue,
-							})
-
-							acc[key] = {
-								type:
-									currentField.required && !forceRequiredToFalse
-										? new GraphQLNonNull(graphqlType)
-										: graphqlType,
-							}
-						}
-
-						return acc
-					}
-
-					const graphqlType = getGraphqlType({
-						...currentField,
-						// We never come here, complicated to good type this
-						type: currentField?.type as WabePrimaryTypes,
-						isWhereType,
-					})
-
-					acc[key] = {
-						type:
-							currentField?.required && !forceRequiredToFalse
-								? new GraphQLNonNull(graphqlType)
-								: graphqlType,
-					}
-
-					return acc
-				},
-				{} as Record<string, any>,
-			)
-
-			return graphqlFields
-		}
-
-		// ------------------ Parsers ------------------
-
-		// Parse simple object
-		const _parseWabeObject = ({
-			required,
-			description,
-			objectToParse,
-			nameOfTheObject,
-		}: ParseObjectOptions) => {
-			const graphqlFields = _getGraphqlFieldsFromAnObject({
-				objectToParse,
-				callBackForObjectType: _parseWabeObject,
-				nameOfTheObject,
-			})
-
-			const graphqlObject = new GraphQLObjectType({
-				name: nameOfTheObject,
-				description: description,
-				fields: graphqlFields,
-			})
-
-			return required ? new GraphQLNonNull(graphqlObject) : graphqlObject
-		}
-
-		// Parse input object
-		const _parseWabeInputObject = ({
-			required,
-			description,
-			objectToParse,
-			nameOfTheObject,
-		}: ParseObjectOptions) => {
-			const graphqlFields = _getGraphqlFieldsFromAnObject({
-				objectToParse,
-				callBackForObjectType: _parseWabeInputObject,
-				nameOfTheObject,
-			})
-
-			const graphqlObject = new GraphQLInputObjectType({
-				name: `${nameOfTheObject}Input`,
-				description: description,
-				fields: graphqlFields,
-			})
-
-			return required ? new GraphQLNonNull(graphqlObject) : graphqlObject
-		}
-
-		// Parse create input object
-		const _parseWabeCreateInputObject = ({
-			required,
-			description,
-			objectToParse,
-			nameOfTheObject,
-		}: ParseObjectOptions) => {
-			const graphqlFields = _getGraphqlFieldsFromAnObject({
-				objectToParse,
-				callBackForObjectType: _parseWabeCreateInputObject,
-				forceRequiredToFalse: true,
-				nameOfTheObject,
-			})
-
-			const graphqlObject = new GraphQLInputObjectType({
-				name: `${nameOfTheObject}CreateFieldsInput`,
-				description: description,
-				fields: graphqlFields,
-			})
-
-			return required ? new GraphQLNonNull(graphqlObject) : graphqlObject
-		}
-
-		// Parse update input object
-		const _parseWabeUpdateInputObject = ({
-			required,
-			description,
-			objectToParse,
-			nameOfTheObject,
-		}: ParseObjectOptions) => {
-			const graphqlFields = _getGraphqlFieldsFromAnObject({
-				objectToParse,
-				callBackForObjectType: _parseWabeUpdateInputObject,
-				forceRequiredToFalse: true,
-				nameOfTheObject,
-			})
-
-			const graphqlObject = new GraphQLInputObjectType({
-				name: `${nameOfTheObject}UpdateFieldsInput`,
-				description: description,
-				fields: graphqlFields,
-			})
-
-			return required ? new GraphQLNonNull(graphqlObject) : graphqlObject
-		}
-
-		// Parse where input object
-		const _parseWabeWhereInputObject = ({
-			required,
-			description,
-			objectToParse,
-			nameOfTheObject,
-		}: ParseObjectOptions) => {
-			const graphqlFields = _getGraphqlFieldsFromAnObject({
-				objectToParse,
-				callBackForObjectType: _parseWabeWhereInputObject,
-				forceRequiredToFalse: true,
-				isWhereType: true,
-				nameOfTheObject,
-			})
-
-			const graphqlObject = new GraphQLInputObjectType({
-				name: `${nameOfTheObject}WhereInput`,
-				description: description,
-				fields: (): any => ({
-					...graphqlFields,
-					OR: {
-						type: new GraphQLList(graphqlObject),
-					},
-					AND: {
-						type: new GraphQLList(graphqlObject),
-					},
-				}),
-			})
-
-			return required ? new GraphQLNonNull(graphqlObject) : graphqlObject
-		}
-
-		const _graphqlObjectFactory: Record<
-			GraphqlObjectType,
-			{
-				callback: ParseObjectCallback
-				isWhereType: boolean
-				forceRequiredToFalse: boolean
-			}
-		> = {
-			Object: {
-				callback: _parseWabeObject,
-				isWhereType: false,
-				forceRequiredToFalse: false,
-			},
-			InputObject: {
-				callback: _parseWabeInputObject,
-				isWhereType: false,
-				forceRequiredToFalse: false,
-			},
-			CreateFieldsInput: {
-				callback: _parseWabeCreateInputObject,
-				isWhereType: false,
-				forceRequiredToFalse: true,
-			},
-			UpdateFieldsInput: {
-				callback: _parseWabeUpdateInputObject,
-				isWhereType: false,
-				forceRequiredToFalse: true,
-			},
-			WhereInputObject: {
-				callback: _parseWabeWhereInputObject,
-				isWhereType: true,
-				forceRequiredToFalse: true,
-			},
-		}
-
-		// Get the good graphql type for a field
-		const getGraphqlType = ({
-			type,
-			typeValue,
-			requiredValue,
-			isWhereType = false,
-		}: {
-			type: WabePrimaryTypes | 'Array' | keyof WabeTypes['enums'] | WabeTypes['scalars']
-			typeValue?: WabePrimaryTypes
-			requiredValue?: boolean
-			isWhereType?: boolean
-		}) => {
-			const scalarExist = scalars.find((scalar) => scalar.name === type)
-
-			const enumExist = enums.find((e) => e.name === type)
-
-			if (isWhereType) {
-				if (!Object.keys(templateWhereInput).includes(type)) return AnyWhereInput
-
-				return templateWhereInput[type as WabePrimaryTypes]
-			}
-
-			if (scalarExist) return scalarExist
-			if (enumExist) return enumExist
-
-			const graphqlType =
-				type === 'Array' && typeValue
-					? new GraphQLList(
-							requiredValue
-								? new GraphQLNonNull(templateScalarType[typeValue])
-								: templateScalarType[typeValue],
-						)
-					: // @ts-expect-error
-						templateScalarType[type]
-
-			if (!graphqlType) throw new Error(`${type} not exist in schema`)
-
-			return graphqlType
-		}
-
-		// Get Graphql object from a schema fields passed in WabeGraphqlParser
-		const getGraphqlFields = (nameOfTheObject: string) => {
-			const { callback, forceRequiredToFalse, isWhereType } =
-				_graphqlObjectFactory[graphqlObjectType]
-
-			const keysOfObject = Object.keys(schemaFields)
-
-			const rawFields = keysOfObject.reduce(
-				(acc, key) => {
-					const currentField = schemaFields[key]
-
-					const isRelation = currentField?.type === 'Relation'
-					const isPointer = currentField?.type === 'Pointer'
-
-					if (isRelation || isPointer) {
-						const graphqlObject = allObjects[currentField.class]
-
-						switch (graphqlObjectType) {
-							case 'Object': {
-								acc[key] = {
-									type: isRelation ? graphqlObject?.connectionObject : graphqlObject?.object,
-								}
-
-								break
-							}
-							case 'UpdateFieldsInput':
-							case 'CreateFieldsInput':
-							case 'InputObject': {
-								acc[key] = {
-									type: isRelation
-										? graphqlObject?.relationInputObject
-										: graphqlObject?.pointerInputObject,
-								}
-
-								break
-							}
-							case 'WhereInputObject': {
-								acc[key] = {
-									type: allObjects[currentField.class]?.whereInputObject,
-								}
-
-								break
-							}
-						}
-
-						return acc
-					}
-
-					if (currentField?.type === 'File') {
-						if (graphqlObjectType === 'Object')
-							acc[key] = {
-								type: currentField.required
-									? new GraphQLNonNull(allObjects.FileInfo?.object)
-									: allObjects.FileInfo?.object,
-							}
-
-						if (
-							graphqlObjectType === 'CreateFieldsInput' ||
-							graphqlObjectType === 'UpdateFieldsInput'
-						) {
-							acc[key] = {
-								type: currentField.required
-									? new GraphQLNonNull(allObjects.FileInfo?.inputObject)
-									: allObjects.FileInfo?.inputObject,
-							}
-						}
-
-						return acc
-					}
-
-					if (currentField?.type === 'Object') {
-						acc[key] = {
-							type: callback({
-								...currentField,
-								objectToParse: currentField.object,
-								nameOfTheObject: `${nameOfTheObject}${currentField.object.name}`,
-							}),
-						}
-
-						return acc
-					}
-
-					if (currentField?.type === 'Array') {
-						if (currentField.typeValue === 'Object') {
-							const objectList = new GraphQLList(
-								callback({
-									...currentField,
-									required: currentField.object.required,
-									objectToParse: currentField.object,
-									nameOfTheObject: `${nameOfTheObject}${currentField.object.name}`,
-								}),
-							)
-
-							acc[key] = {
-								type: currentField.required ? new GraphQLNonNull(objectList) : objectList,
-							}
-
-							return acc
-						}
-					}
-
-					const graphqlType = getGraphqlType({
-						...currentField,
-						type: currentField?.type,
-						isWhereType,
-					})
-
-					acc[key] = {
-						type:
-							currentField?.required && !forceRequiredToFalse
-								? new GraphQLNonNull(graphqlType)
-								: graphqlType,
-					}
-
-					return acc
-				},
-				{} as Record<string, any>,
-			)
-
-			return Object.keys(rawFields).reduce(
-				(acc, key) => {
-					const field = rawFields[key]
-
-					acc[key] = field
-
-					return acc
-				},
-				{} as Record<string, GraphQLFieldConfig<any, any, any>>,
-			)
-		}
-
-		return {
-			getGraphqlType,
-			getGraphqlFields,
-			_parseWabeObject,
-			_parseWabeInputObject,
-			_parseWabeUpdateInputObject,
-			_parseWabeWhereInputObject,
-		}
-	}

package/src/graphql/pointerAndRelationFunction.ts

@@ -1,191 +0,0 @@
-import { getClassFromClassName } from '../utils'
-import type { WabeContext } from '../server/interface'
-import { notEmpty } from '../utils/export'
-
-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 const createAndLink = async ({
-	createAndLink,
-	context,
-	fieldName,
-	className,
-}: {
-	createAndLink: CreateAndLink
-	fieldName: string
-	context: WabeContext<any>
-	className: string
-}) => {
-	const classInSchema = getClassFromClassName(className, context.wabe.config)
-
-	const res = await context.wabe.controllers.database.createObject({
-		// @ts-expect-error
-		className: classInSchema.fields[fieldName].class,
-		data: createAndLink,
-		select: { id: true },
-		context,
-	})
-
-	return res?.id
-}
-
-export const createAndAdd = async ({
-	createAndAdd,
-	context,
-	fieldName,
-	className,
-}: {
-	createAndAdd: CreateAndAdd
-	fieldName: string
-	context: WabeContext<any>
-	className: string
-}) => {
-	const classInSchema = getClassFromClassName(className, context.wabe.config)
-
-	const result = await context.wabe.controllers.database.createObjects({
-		// @ts-expect-error
-		className: classInSchema.fields[fieldName].class,
-		data: createAndAdd,
-		select: { id: true },
-		context,
-	})
-
-	return result.map((object: any) => object.id)
-}
-
-export const add = async ({
-	add,
-	context,
-	fieldName,
-	typeOfExecution,
-	id,
-	className,
-	where,
-}: {
-	add: Add
-	fieldName: string
-	context: WabeContext<any>
-	typeOfExecution: TypeOfExecution
-	id?: string
-	className: string
-	where: any
-}) => {
-	if (typeOfExecution === 'create') return add
-
-	if (typeOfExecution === 'update' && id) {
-		const currentValue = await context.wabe.controllers.database.getObject({
-			className,
-			id,
-			select: { [fieldName]: true },
-			context,
-		})
-
-		const currentValueIds = currentValue?.[fieldName]?.map((object: any) => object.id) || []
-
-		return [...currentValueIds, ...add].filter(notEmpty)
-	}
-
-	// For update many we need to get all objects that match the where and add the new value
-	// So we doesn't update the field for updateMany
-	if (typeOfExecution === 'updateMany' && where) {
-		const allObjectsMatchedWithWhere = await context.wabe.controllers.database.getObjects({
-			className,
-			where,
-			select: { [fieldName]: true },
-			context,
-		})
-
-		return Promise.all(
-			allObjectsMatchedWithWhere.flatMap((object: any) => {
-				const currentValueIds = object[fieldName]?.map((object: any) => object.id) || []
-
-				return [...currentValueIds, ...add]
-			}),
-		)
-	}
-}
-
-export const remove = async ({
-	remove,
-	context,
-	fieldName,
-	typeOfExecution,
-	id,
-	className,
-	where,
-}: {
-	remove: Remove
-	fieldName: string
-	context: WabeContext<any>
-	typeOfExecution: TypeOfExecution
-	id?: string
-	className: string
-	where: any
-}) => {
-	if (typeOfExecution === 'create') return []
-
-	const classInSchema = getClassFromClassName(className, context.wabe.config)
-
-	if (typeOfExecution === 'update' && id) {
-		const currentValue = await context.wabe.controllers.database.getObject({
-			className,
-			id,
-			select: { [fieldName]: true },
-			context,
-		})
-
-		const olderValuesIds = currentValue?.[fieldName]?.map((object: any) => object.id) || []
-
-		await context.wabe.controllers.database.deleteObjects({
-			// @ts-expect-error
-			className: classInSchema.fields[fieldName].class,
-			where: { id: { in: remove } },
-			context,
-			select: {},
-		})
-
-		return olderValuesIds.filter((olderValue: any) => !remove.includes(olderValue))
-	}
-
-	if (typeOfExecution === 'updateMany' && where) {
-		const allObjectsMatchedWithWhere = await context.wabe.controllers.database.getObjects({
-			className,
-			where,
-			select: { [fieldName]: true },
-			context,
-		})
-
-		const olderValuesIds = allObjectsMatchedWithWhere.flatMap(
-			(object: any) => object[fieldName]?.map((object: any) => object.id) || [],
-		)
-
-		await context.wabe.controllers.database.deleteObjects({
-			// @ts-expect-error
-			className: classInSchema.fields[fieldName].class,
-			where: { id: { in: remove } },
-			context,
-			select: {},
-		})
-
-		return olderValuesIds.filter((olderValue: any) => !remove.includes(olderValue))
-	}
-}