wabe 0.6.12 → 0.6.14

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))
-	}
-}

package/src/graphql/resolvers.ts

@@ -1,464 +0,0 @@
-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'
-
-import { valueFromASTUntyped } from 'graphql'
-
-const expandFragmentSpread = (
-	fragmentSpread: FragmentSpreadNode,
-	fragments: Record<string, FragmentDefinitionNode>,
-	className: string,
-	variables?: Record<string, any>,
-): 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, {
-		variables,
-	})
-}
-
-export const extractFieldsFromSetNode = (
-	selectionSet: SelectionSetNode,
-	className: string,
-	fragments?: Record<string, FragmentDefinitionNode>,
-	options?: { ignoreClassField?: boolean; variables?: Record<string, any> },
-): 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,
-					options?.variables,
-				)
-				return { ...acc, ...fragmentFields }
-			}
-
-			//@ts-expect-error
-			const currentValue = selection.name.value
-
-			const _args =
-				selection.kind === 'Field' && selection.arguments && selection.arguments.length > 0
-					? selection.arguments.reduce(
-							(argAcc, arg) => ({
-								...argAcc,
-								[arg.name.value]: valueFromASTUntyped(arg.value, options?.variables),
-							}),
-							{} as Record<string, any>,
-						)
-					: undefined
-
-			if (selection.selectionSet?.selections && selection.selectionSet?.selections?.length > 0) {
-				const res = extractFieldsFromSetNode(selection.selectionSet, className, fragments, {
-					ignoreClassField: false,
-					variables: options?.variables,
-				})
-
-				if (ignoredFields.indexOf(currentValue) === -1)
-					return {
-						...acc,
-						[currentValue]: _args ? { ...res, _args } : res,
-					}
-
-				return {
-					...acc,
-					...res,
-				}
-			}
-
-			if (ignoredFields.indexOf(currentValue) === -1) {
-				acc[currentValue] = _args ? { _args } : 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, {
-		variables: info.variableValues,
-	})
-
-	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 })),
-	}
-}