wabe 0.6.9 → 0.6.10

package/src/hooks/searchableFields.test.ts

@@ -0,0 +1,166 @@
+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

@@ -0,0 +1,98 @@
+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

@@ -0,0 +1,138 @@
+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

@@ -0,0 +1,78 @@
+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

@@ -0,0 +1,216 @@
+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
+					}
+				}
+			}
+		}
+	`,
+}