wabe 0.6.9 → 0.6.10

package/src/graphql/pointerAndRelationFunction.ts

@@ -0,0 +1,200 @@
+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),
+		)
+	}
+}

package/src/graphql/resolvers.ts

@@ -0,0 +1,467 @@
+import type {
+	GraphQLResolveInfo,
+	SelectionSetNode,
+	FragmentSpreadNode,
+	FragmentDefinitionNode,
+} from 'graphql'
+import type { WabeTypes } from '..'
+import type { WabeContext } from '../server/interface'
+import { contextWithoutGraphQLCall, firstLetterInLowerCase } from '../utils'
+import {
+	type InputFields,
+	type TypeOfExecution,
+	add,
+	createAndAdd,
+	createAndLink,
+	remove,
+} from './pointerAndRelationFunction'
+
+const expandFragmentSpread = (
+	fragmentSpread: FragmentSpreadNode,
+	fragments: Record<string, FragmentDefinitionNode>,
+	className: string,
+): Record<string, any> => {
+	const fragmentName = fragmentSpread.name.value
+	const fragmentDef = fragments[fragmentName]
+
+	if (!fragmentDef) {
+		throw new Error(`Fragment "${fragmentName}" not found`)
+	}
+
+	return extractFieldsFromSetNode(
+		fragmentDef.selectionSet,
+		className,
+		fragments,
+	)
+}
+
+export const extractFieldsFromSetNode = (
+	selectionSet: SelectionSetNode,
+	className: string,
+	fragments?: Record<string, FragmentDefinitionNode>,
+	options?: { ignoreClassField?: boolean },
+): Record<string, any> => {
+	const ignoredFields = ['edges', 'node', 'clientMutationId', 'ok']
+	const shouldIgnoreClassField = options?.ignoreClassField ?? true
+
+	if (shouldIgnoreClassField && className)
+		ignoredFields.push(firstLetterInLowerCase(className))
+
+	return selectionSet.selections?.reduce(
+		(acc, selection) => {
+			// Handle fragment spreads
+			if (selection.kind === 'FragmentSpread') {
+				if (!fragments) {
+					throw new Error('Fragment spreads require fragments to be provided')
+				}
+				const fragmentFields = expandFragmentSpread(
+					selection as FragmentSpreadNode,
+					fragments,
+					className,
+				)
+				return { ...acc, ...fragmentFields }
+			}
+
+			//@ts-expect-error
+			const currentValue = selection.name.value
+
+			if (
+				selection.selectionSet?.selections &&
+				selection.selectionSet?.selections?.length > 0
+			) {
+				const res = extractFieldsFromSetNode(
+					selection.selectionSet,
+					className,
+					fragments,
+					{ ignoreClassField: false },
+				)
+
+				if (ignoredFields.indexOf(currentValue) === -1)
+					return {
+						...acc,
+						[currentValue]: res,
+					}
+
+				return {
+					...acc,
+					...res,
+				}
+			}
+
+			if (ignoredFields.indexOf(currentValue) === -1) acc[currentValue] = true
+
+			return acc
+		},
+		{} as Record<string, any>,
+	)
+}
+
+const getFieldsFromInfo = (info: GraphQLResolveInfo, className: string) => {
+	const selectionSet = info.fieldNodes[0]?.selectionSet
+
+	if (!selectionSet) throw new Error('No output fields provided')
+
+	const fields = extractFieldsFromSetNode(
+		selectionSet,
+		className,
+		info.fragments,
+	)
+
+	if (!fields) throw new Error('No fields provided')
+
+	return fields
+}
+
+export const getFieldsOfClassName = ({
+	fields,
+	className,
+	context,
+}: {
+	fields: string[]
+	className: string
+	context: WabeContext<any>
+}): {
+	classFields: string[]
+	othersFields: string[]
+} => {
+	const classFields = context.wabe.config.schema?.classes?.find(
+		(schemaClass) => schemaClass.name === className,
+	)?.fields
+
+	if (!classFields) return { classFields: [], othersFields: fields }
+
+	const sameFieldsAsClass = fields.filter((field) => {
+		// If the field exist in the class
+		// id is automatically include in a class but not provided in fields
+		if (classFields[field] || field === 'id') return true
+
+		// If the name of the field is include in the field provided
+		// For example if a pointer field name "Role" is include in the field "role.name"
+		if (
+			Object.keys(classFields).find((classField) => field.includes(classField))
+		)
+			return true
+
+		return false
+	})
+
+	const othersFields = fields.filter(
+		(field) => !sameFieldsAsClass.includes(field),
+	)
+
+	return { classFields: sameFieldsAsClass, othersFields }
+}
+
+export const executeRelationOnFields = ({
+	className,
+	fields,
+	context,
+	id,
+	typeOfExecution,
+	where,
+}: {
+	className: string
+	fields: InputFields
+	context: WabeContext<any>
+	id?: string
+	where?: any
+	typeOfExecution?: TypeOfExecution
+}) => {
+	const entries = Object.entries(fields)
+
+	return entries.reduce(
+		async (acc, [fieldName, value]) => {
+			const newAcc = await acc
+
+			if (value instanceof File) {
+				newAcc[fieldName] = value
+			} else if (typeof value === 'object' && value?.createAndLink) {
+				newAcc[fieldName] = await createAndLink({
+					createAndLink: value.createAndLink,
+					fieldName,
+					context: contextWithoutGraphQLCall(context),
+					className,
+				})
+			} else if (typeof value === 'object' && value?.link) {
+				newAcc[fieldName] = value.link
+			} else if (typeof value === 'object' && value.unlink) {
+				newAcc[fieldName] = null
+			} else if (typeof value === 'object' && value?.createAndAdd) {
+				newAcc[fieldName] = await createAndAdd({
+					createAndAdd: value.createAndAdd,
+					fieldName,
+					context: contextWithoutGraphQLCall(context),
+					className,
+				})
+			} else if (typeof value === 'object' && value?.add) {
+				const addValue = await add({
+					add: value.add,
+					context: contextWithoutGraphQLCall(context),
+					fieldName,
+					typeOfExecution: typeOfExecution || 'create',
+					id,
+					className,
+					where,
+				})
+
+				if (addValue) newAcc[fieldName] = addValue
+			} else if (typeof value === 'object' && value?.remove) {
+				const removeValue = await remove({
+					remove: value.remove,
+					context: contextWithoutGraphQLCall(context),
+					fieldName,
+					typeOfExecution: typeOfExecution || 'create',
+					id,
+					className,
+					where,
+				})
+
+				if (removeValue) newAcc[fieldName] = removeValue
+			} else {
+				newAcc[fieldName] = value
+			}
+
+			return newAcc
+		},
+		Promise.resolve({}) as Promise<Record<string, any>>,
+	)
+}
+
+const transformOrder = (
+	order?: Array<string>,
+): Record<string, 'ASC' | 'DESC'> =>
+	order?.reduce(
+		(acc, currentOrder) => {
+			const result = Object.entries(currentOrder)[0]
+
+			if (!result || !result[0] || !result[1]) return acc
+
+			// @ts-expect-error
+			acc[result[0]] = result[1]
+
+			return acc
+		},
+		{} as Record<string, 'ASC' | 'DESC'>,
+	) || {}
+
+export const queryForOneObject = (
+	_: any,
+	{ id }: any,
+	context: WabeContext<any>,
+	info: GraphQLResolveInfo,
+	className: keyof WabeTypes['types'],
+) => {
+	const select = getFieldsFromInfo(info, className)
+
+	return context.wabe.controllers.database.getObject({
+		className,
+		id,
+		select,
+		context,
+	})
+}
+
+export const queryForMultipleObject = async (
+	_: any,
+	{ where, offset, first, order }: any,
+	context: WabeContext<any>,
+	info: GraphQLResolveInfo,
+	className: keyof WabeTypes['types'],
+) => {
+	const select = getFieldsFromInfo(info, className)
+
+	const { totalCount, ...selectWithoutTotalCount } = select
+
+	const objects = await context.wabe.controllers.database.getObjects({
+		className,
+		where,
+		select: selectWithoutTotalCount,
+		offset,
+		first,
+		context,
+		order: transformOrder(order),
+	})
+
+	return {
+		totalCount: totalCount
+			? await context.wabe.controllers.database.count({
+					className,
+					where,
+					context,
+				})
+			: undefined,
+		edges: objects.map((object: any) => ({
+			node: object,
+		})),
+	}
+}
+
+export const mutationToCreateObject = async (
+	_: any,
+	args: any,
+	context: WabeContext<any>,
+	info: GraphQLResolveInfo,
+	className: keyof WabeTypes['types'],
+) => {
+	const select = getFieldsFromInfo(info, className)
+
+	const updatedFieldsToCreate = await executeRelationOnFields({
+		className,
+		fields: args.input?.fields,
+		context,
+	})
+
+	return {
+		[firstLetterInLowerCase(className)]:
+			await context.wabe.controllers.database.createObject({
+				className,
+				data: updatedFieldsToCreate,
+				select,
+				context,
+			}),
+		ok: true,
+	}
+}
+
+export const mutationToCreateMultipleObjects = async (
+	_: any,
+	{ input: { fields, offset, first, order } }: any,
+	context: WabeContext<any>,
+	info: GraphQLResolveInfo,
+	className: keyof WabeTypes['types'],
+) => {
+	const select = getFieldsFromInfo(info, className)
+	const inputFields = fields as Array<any>
+
+	const updatedFieldsToCreate = await Promise.all(
+		inputFields.map((inputField) =>
+			executeRelationOnFields({
+				className,
+				fields: inputField,
+				context,
+			}),
+		),
+	)
+
+	const objects = await context.wabe.controllers.database.createObjects({
+		className,
+		data: updatedFieldsToCreate,
+		select,
+		offset,
+		first,
+		context,
+		order: transformOrder(order),
+	})
+
+	return {
+		edges: objects.map((object: any) => ({ node: object })),
+	}
+}
+
+export const mutationToUpdateObject = async (
+	_: any,
+	args: any,
+	context: WabeContext<any>,
+	info: GraphQLResolveInfo,
+	className: keyof WabeTypes['types'],
+) => {
+	const select = getFieldsFromInfo(info, className)
+
+	const updatedFields = await executeRelationOnFields({
+		className,
+		fields: args.input?.fields,
+		context,
+		id: args.input?.id,
+		typeOfExecution: 'update',
+	})
+
+	return {
+		[firstLetterInLowerCase(className)]:
+			await context.wabe.controllers.database.updateObject({
+				className,
+				id: args.input?.id,
+				data: updatedFields,
+				select,
+				context,
+			}),
+		ok: true,
+	}
+}
+
+export const mutationToUpdateMultipleObjects = async (
+	_: any,
+	{ input: { fields, where, offset, first, order } }: any,
+	context: WabeContext<any>,
+	info: GraphQLResolveInfo,
+	className: keyof WabeTypes['types'],
+) => {
+	const select = getFieldsFromInfo(info, className)
+
+	const updatedFields = await executeRelationOnFields({
+		className,
+		fields,
+		context,
+		typeOfExecution: 'updateMany',
+		where,
+	})
+
+	const objects = await context.wabe.controllers.database.updateObjects({
+		className,
+		where,
+		data: updatedFields,
+		select,
+		offset,
+		first,
+		context,
+		order,
+	})
+
+	return {
+		edges: objects.map((object: any) => ({ node: object })),
+	}
+}
+
+export const mutationToDeleteObject = async (
+	_: any,
+	args: any,
+	context: WabeContext<any>,
+	info: GraphQLResolveInfo,
+	className: keyof WabeTypes['types'],
+) => {
+	const select = getFieldsFromInfo(info, className)
+
+	return {
+		[firstLetterInLowerCase(className)]:
+			await context.wabe.controllers.database.deleteObject({
+				className,
+				id: args.input?.id,
+				select,
+				context,
+			}),
+		ok: true,
+	}
+}
+
+export const mutationToDeleteMultipleObjects = async (
+	_: any,
+	{ input: { where, offset, first, order } }: any,
+	context: WabeContext<any>,
+	info: GraphQLResolveInfo,
+	className: keyof WabeTypes['types'],
+) => {
+	const select = getFieldsFromInfo(info, className)
+
+	const objects = await context.wabe.controllers.database.deleteObjects({
+		className,
+		where,
+		select,
+		offset,
+		first,
+		context,
+		order,
+	})
+
+	return {
+		edges: objects.map((object: any) => ({ node: object })),
+	}
+}