wabe 0.6.12 → 0.6.14

package/src/hooks/searchableFields.test.ts

@@ -1,147 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from 'bun:test'
-import {
-	defaultSearchableFieldsBeforeCreate,
-	defaultSearchableFieldsBeforeUpdate,
-	stringExtraction,
-} from './searchableFields'
-import { HookObject } from './HookObject'
-import type { DevWabeTypes } from '../utils/helper'
-import { setupTests, closeTests } from '../utils/testHelper'
-import { OperationType } from '.'
-import type { Wabe } from '../server'
-
-describe('searchablesFields', () => {
-	let wabe: Wabe<DevWabeTypes>
-
-	beforeAll(async () => {
-		const setup = await setupTests()
-		wabe = setup.wabe
-	})
-
-	afterAll(async () => {
-		await closeTests(wabe)
-	})
-
-	it('should extract searchable fields from email (searchableFields hook should be after emails hook)', async () => {
-		await wabe.controllers.database.createObject({
-			className: 'User',
-			context: {
-				isRoot: true,
-				wabe,
-			},
-			data: {
-				authentication: {
-					emailPassword: {
-						email: 'admin@wabe.dev',
-						password: 'admin',
-					},
-				},
-			},
-			select: {},
-		})
-
-		const res = await wabe.controllers.database.getObjects({
-			className: 'User',
-			select: { search: true },
-			context: {
-				isRoot: true,
-				wabe,
-			},
-		})
-
-		expect(res[0]?.search).toEqual([
-			'a',
-			'ad',
-			'adm',
-			'admi',
-			'admin',
-			'w',
-			'wa',
-			'wab',
-			'wabe',
-			'd',
-			'de',
-			'dev',
-		])
-	})
-
-	it('should extract string correctly', () => {
-		expect(stringExtraction('test')).toEqual(['t', 'te', 'tes', 'test'])
-
-		expect(
-			stringExtraction({
-				test: 0,
-				tata: 'ceci',
-			}),
-		).toEqual(['0', 'c', 'ce', 'cec', 'ceci'])
-
-		expect(stringExtraction('es pace')).toEqual(['e', 'es', 'p', 'pa', 'pac', 'pace'])
-	})
-
-	it('should complete the search fields of each object on insert', () => {
-		const hookObject = new HookObject<DevWabeTypes, 'User'>({
-			className: 'User',
-			operationType: OperationType.BeforeCreate,
-			newData: {
-				email: 'email@test.fr',
-				name: 'Test',
-				age: 20,
-			} as any,
-			context: {
-				wabe: {
-					config: {
-						schema: {
-							classes: [
-								{
-									name: 'User',
-									searchableFields: ['name', 'age'],
-								},
-							],
-						},
-					},
-				},
-			} as any,
-			object: {} as any,
-			select: {},
-		})
-
-		defaultSearchableFieldsBeforeCreate(hookObject)
-
-		expect(hookObject.getNewData().search).toEqual(['t', 'te', 'tes', 'test', '20'])
-	})
-
-	it('should complete the search fields of each object on update', () => {
-		const hookObject = new HookObject<DevWabeTypes, 'User'>({
-			className: 'User',
-			operationType: OperationType.BeforeUpdate,
-			newData: {
-				email: 'email@test.fr',
-				name: 'tata',
-				age: 20,
-			} as any,
-			context: {
-				wabe: {
-					config: {
-						schema: {
-							classes: [
-								{
-									name: 'User',
-									searchableFields: ['name', 'age'],
-								},
-							],
-						},
-					},
-				},
-			} as any,
-			object: {
-				name: 'test',
-				search: ['t', 'te', 'tes', 'test'],
-			} as any,
-			select: {},
-		})
-
-		defaultSearchableFieldsBeforeUpdate(hookObject)
-
-		expect(hookObject.getNewData().search).toEqual(['t', 'ta', 'tat', 'tata', '20'])
-	})
-})

package/src/hooks/searchableFields.ts

@@ -1,86 +0,0 @@
-import { tokenize } from '../utils'
-import { notEmpty } from '../utils/export'
-import type { HookObject } from './HookObject'
-
-export const stringExtraction = (value: any): Array<string> => {
-	if (value === undefined || value === null) return []
-
-	if (typeof value === 'object') return Object.values(value).flatMap((v) => stringExtraction(v))
-
-	if (typeof value === 'string')
-		return tokenize(value)
-			.trim()
-			.split(' ')
-			.map((word: string) => word.trim())
-			.flatMap((word: string) => {
-				const arrayOfString = []
-
-				for (let i = 1; i <= word.length; i += 1)
-					arrayOfString.push(word.substring(0, i).toLowerCase())
-
-				return arrayOfString
-			})
-
-	if (typeof value === 'number') return [String(value)]
-
-	return []
-}
-
-export const defaultSearchableFieldsBeforeCreate = (object: HookObject<any, any>) => {
-	const searchablesFields = object.context.wabe.config.schema?.classes?.find(
-		(currentClass) => currentClass.name === object.className,
-	)?.searchableFields
-
-	if (!searchablesFields || searchablesFields.length === 0) return
-
-	const newData = object.getNewData()
-
-	const extractedSearchField = Object.entries(newData)
-		.flatMap(([key, value]) => {
-			if (!searchablesFields.includes(key)) return undefined
-
-			return stringExtraction(value)
-		})
-		.filter(notEmpty)
-
-	object.upsertNewData('search', extractedSearchField)
-}
-
-export const defaultSearchableFieldsBeforeUpdate = (object: HookObject<any, any>) => {
-	const searchablesFields = object.context.wabe.config.schema?.classes?.find(
-		(currentClass) => currentClass.name === object.className,
-	)?.searchableFields
-
-	if (!searchablesFields || searchablesFields.length === 0) return
-
-	const newData = object.getNewData()
-
-	const newExtractedSearchField = Object.entries(newData)
-		.flatMap(([key, value]) => {
-			if (!searchablesFields.includes(key)) return undefined
-
-			return stringExtraction(value)
-		})
-		.filter(notEmpty)
-
-	const oldExtractedSearcFieldForUpdateFields = Object.entries(object.object || {})
-		.flatMap(([key, value]) => {
-			// If the data is not a searchable field or don't change
-			if (!searchablesFields.includes(key) || !Object.keys(newData).includes(key)) return undefined
-
-			return stringExtraction(value)
-		})
-		.filter(notEmpty)
-
-	const actualSearch = (object.object?.search || []) as string[]
-
-	// Actual search fields minus old search data for same field + new extracted data for the field
-	const extractedSearchFields = [
-		...actualSearch.filter(
-			(element: string) => !oldExtractedSearcFieldForUpdateFields.includes(element),
-		),
-		...newExtractedSearchField,
-	]
-
-	object.upsertNewData('search', extractedSearchFields)
-}

package/src/hooks/session.test.ts

@@ -1,134 +0,0 @@
-import { describe, beforeAll, afterAll, expect, it, beforeEach } from 'bun:test'
-import { gql } from 'graphql-request'
-import type { Wabe } from '../server'
-import { type DevWabeTypes, getAnonymousClient, getUserClient } from '../utils/helper'
-import { setupTests, closeTests } from '../utils/testHelper'
-
-describe('hooks/session', () => {
-	let wabe: Wabe<DevWabeTypes>
-	let port: number
-
-	beforeAll(async () => {
-		const setup = await setupTests()
-		wabe = setup.wabe
-		port = setup.port
-	})
-
-	beforeEach(async () => {
-		await wabe.controllers.database.clearDatabase()
-	})
-
-	afterAll(async () => {
-		await closeTests(wabe)
-	})
-
-	it('should link a new session to user relation after creation', async () => {
-		const anonymousClient = getAnonymousClient(port)
-
-		await anonymousClient.request<any>(graphql.signUpWith, {
-			input: {
-				authentication: {
-					emailPassword: {
-						email: 'email@test.fr',
-						password: 'password',
-					},
-				},
-			},
-		})
-
-		const res = await wabe.controllers.database.getObjects({
-			className: 'User',
-			context: {
-				wabe,
-				isRoot: true,
-			},
-			select: {
-				id: true,
-				sessions: true,
-			},
-		})
-
-		expect(res[0]?.sessions?.length).toEqual(1)
-	})
-
-	it('should unlink a session from user relation after deletion', async () => {
-		const anonymousClient = getAnonymousClient(port)
-
-		const res = await anonymousClient.request<any>(graphql.signUpWith, {
-			input: {
-				authentication: {
-					emailPassword: {
-						email: 'email2@test.fr',
-						password: 'password',
-					},
-				},
-			},
-		})
-
-		const userClient = getUserClient(port, {
-			accessToken: res.signUpWith.accessToken,
-		})
-
-		await userClient.request<any>(graphql.signInWith, {
-			input: {
-				authentication: {
-					emailPassword: {
-						email: 'email2@test.fr',
-						password: 'password',
-					},
-				},
-			},
-		})
-
-		const res2 = await wabe.controllers.database.getObjects({
-			className: 'User',
-			context: {
-				wabe,
-				isRoot: true,
-			},
-			select: {
-				id: true,
-				sessions: true,
-			},
-		})
-
-		await wabe.controllers.database.deleteObjects({
-			className: '_Session',
-			where: {
-				id: { equalTo: res2[0]?.sessions?.[0]?.id },
-			},
-			context: {
-				wabe,
-				isRoot: true,
-			},
-			select: {},
-		})
-
-		const res3 = await wabe.controllers.database.getObjects({
-			className: 'User',
-			context: {
-				wabe,
-				isRoot: true,
-			},
-		})
-
-		expect(res3[0]?.sessions?.length).toEqual(1)
-	})
-})
-
-const graphql = {
-	signUpWith: gql`
-		mutation signUpWith($input: SignUpWithInput!) {
-			signUpWith(input: $input) {
-				accessToken
-			}
-		}
-	`,
-	signInWith: gql`
-		mutation signInWith($input: SignInWithInput!) {
-			signInWith(input: $input) {
-				accessToken
-			}
-		}
-	`,
-}

package/src/hooks/session.ts

@@ -1,76 +0,0 @@
-import type { DevWabeTypes } from '../utils/helper'
-import { notEmpty } from '../utils/export'
-import type { HookObject } from './HookObject'
-
-export const defaultAfterCreateSession = async (
-	hookObject: HookObject<DevWabeTypes, '_Session'>,
-) => {
-	const object = hookObject.object
-	// @ts-expect-error
-	const userId = object?.user as string
-
-	if (!userId) return
-
-	const databaseController = hookObject.context.wabe.controllers.database
-
-	const user = await databaseController.getObject({
-		className: 'User',
-		id: userId,
-		select: {
-			sessions: true,
-		},
-		context: hookObject.context,
-	})
-
-	const sessionsId = user?.sessions?.map((session) => session.id) || []
-
-	await databaseController.updateObject({
-		className: 'User',
-		id: userId,
-		context: hookObject.context,
-		data: {
-			sessions: [...sessionsId, object?.id].filter(notEmpty),
-		},
-	})
-}
-
-export const defaultAfterDeleteSession = async (
-	hookObject: HookObject<DevWabeTypes, '_Session'>,
-) => {
-	const object = hookObject.object
-	// @ts-expect-error
-	const userId = object?.user as string
-
-	if (!userId) return
-
-	const databaseController = hookObject.context.wabe.controllers.database
-
-	const user = await databaseController.getObject({
-		className: 'User',
-		id: userId,
-		select: {
-			sessions: true,
-		},
-		context: hookObject.context,
-	})
-
-	const newSessionsId = user?.sessions
-		?.filter((session) => session.id !== object?.id)
-		.map((session) => session.id)
-
-	await databaseController.updateObject({
-		className: 'User',
-		id: userId,
-		context: hookObject.context,
-		data: {
-			sessions: newSessionsId,
-		},
-	})
-}
-
-export const defaultBeforeUpdateSessionOnUser = (hookObject: HookObject<DevWabeTypes, 'User'>) => {
-	if (hookObject.context.isRoot) return
-
-	if (hookObject.isFieldUpdated('sessions'))
-		throw new Error('Not authorized to update user sessions')
-}

package/src/hooks/setEmail.test.ts

@@ -1,216 +0,0 @@
-import { describe, beforeAll, afterAll, expect, it, afterEach } from 'bun:test'
-import { getGraphqlClient, type DevWabeTypes } from '../utils/helper'
-import { setupTests, closeTests } from '../utils/testHelper'
-import type { Wabe } from '../server'
-import { gql, type GraphQLClient } from 'graphql-request'
-
-describe('setEmail', () => {
-	let wabe: Wabe<DevWabeTypes>
-	let port: number
-	let client: GraphQLClient
-
-	beforeAll(async () => {
-		const setup = await setupTests()
-		wabe = setup.wabe
-		port = setup.port
-		client = getGraphqlClient(port)
-	})
-
-	afterAll(async () => {
-		await closeTests(wabe)
-	})
-
-	afterEach(async () => {
-		await client.request<any>(graphql.deleteUsers)
-	})
-
-	it("should set email if it doesn't exist", async () => {
-		const {
-			signUpWith: { id },
-		} = await client.request<any>(graphql.signUpWith, {
-			input: {
-				authentication: {
-					emailPassword: {
-						email: 'email@test.fr',
-						password: 'password',
-					},
-				},
-			},
-		})
-
-		const { user } = await client.request<any>(graphql.user, {
-			id,
-		})
-
-		expect(user.email).toEqual('email@test.fr')
-		expect(user.provider).toEqual('emailPassword')
-	})
-
-	it('should not set email if it is provided during the creation', async () => {
-		const {
-			createUser: { user },
-		} = await client.request<any>(graphql.createUser, {
-			input: {
-				fields: {
-					name: 'John',
-					age: 23,
-					email: 'email@test.fr',
-				},
-			},
-		})
-
-		expect(user.email).toEqual('email@test.fr')
-		expect(user.provider).toEqual(null)
-	})
-
-	it('should update email if it change during update', async () => {
-		const {
-			createUser: { user },
-		} = await client.request<any>(graphql.createUser, {
-			input: {
-				fields: {
-					name: 'John',
-					age: 23,
-					email: 'email@test.fr',
-				},
-			},
-		})
-
-		const userId = user.id
-
-		const {
-			updateUser: { user: updatedUser },
-		} = await client.request<any>(graphql.updateUser, {
-			input: {
-				id: userId,
-				fields: {
-					authentication: {
-						emailPassword: {
-							email: 'updated@test.fr',
-						},
-					},
-				},
-			},
-		})
-
-		expect(updatedUser.email).toEqual('updated@test.fr')
-		expect(updatedUser.provider).toEqual('emailPassword')
-	})
-
-	it('should not update email if email is provided', async () => {
-		const {
-			createUser: { user },
-		} = await client.request<any>(graphql.createUser, {
-			input: {
-				fields: {
-					name: 'John',
-					age: 23,
-					email: 'email@test.fr',
-				},
-			},
-		})
-
-		const userId = user.id
-
-		const {
-			updateUser: { user: updatedUser },
-		} = await client.request<any>(graphql.updateUser, {
-			input: {
-				id: userId,
-				fields: {
-					authentication: {
-						emailPassword: {
-							email: 'updated@test.fr',
-						},
-					},
-					email: 'updated2@test.fr',
-				},
-			},
-		})
-
-		expect(updatedUser.email).toEqual('updated2@test.fr')
-		expect(updatedUser.provider).toEqual(null)
-	})
-
-	it('should not update email if email is provided but not authentication field', async () => {
-		const {
-			createUser: { user },
-		} = await client.request<any>(graphql.createUser, {
-			input: {
-				fields: {
-					name: 'John',
-					age: 23,
-					email: 'email@test.fr',
-				},
-			},
-		})
-
-		const userId = user.id
-
-		const {
-			updateUser: { user: updatedUser },
-		} = await client.request<any>(graphql.updateUser, {
-			input: {
-				id: userId,
-				fields: {
-					email: 'updated2@test.fr',
-				},
-			},
-		})
-
-		expect(updatedUser.email).toEqual('updated2@test.fr')
-		expect(updatedUser.provider).toEqual(null)
-	})
-})
-
-const graphql = {
-	signUpWith: gql`
-		mutation signUpWith($input: SignUpWithInput!) {
-			signUpWith(input: $input) {
-				id
-			}
-		}
-	`,
-	user: gql`
-		query user($id: ID!) {
-			user(id: $id) {
-				id
-				email
-				provider
-			}
-		}
-	`,
-	createUser: gql`
-		mutation createUser($input: CreateUserInput!) {
-			createUser(input: $input) {
-				user {
-					id
-					email
-					provider
-				}
-			}
-		}
-	`,
-	updateUser: gql`
-		mutation updateUser($input: UpdateUserInput!) {
-			updateUser(input: $input) {
-				user {
-					id
-					email
-					provider
-				}
-			}
-		}
-	`,
-	deleteUsers: gql`
-		mutation deleteUsers {
-			deleteUsers(input: {}) {
-				edges {
-					node {
-						id
-					}
-				}
-			}
-		}
-	`,
-}

package/src/hooks/setEmail.ts

@@ -1,33 +0,0 @@
-import type { DevWabeTypes } from '../utils/helper'
-import type { HookObject } from './HookObject'
-
-const updateEmail = (object: HookObject<DevWabeTypes, 'User'>) => {
-	const authentication = object.getNewData().authentication
-
-	if (!authentication) return
-
-	// Considering that we only have one authentication provider (for double auth maybe need an adjustment)
-	const provider = Object.keys(authentication)[0] || ''
-
-	const emailToSave = authentication[provider].email
-
-	if (!emailToSave) return
-
-	object.upsertNewData('email', emailToSave)
-
-	if (provider) object.upsertNewData('provider', provider)
-}
-
-// This hook works for official authentication provider that store email in "email" field
-// Maybe need custom hook for custom authentication provider
-export const defaultSetEmail = (object: HookObject<DevWabeTypes, 'User'>) => {
-	if (object.isFieldUpdated('email')) return
-
-	updateEmail(object)
-}
-
-export const defaultSetEmailOnUpdate = (object: HookObject<DevWabeTypes, 'User'>) => {
-	if (object.isFieldUpdated('email')) return
-
-	updateEmail(object)
-}