wabe 0.6.9 → 0.6.10

package/src/graphql/tests/scalars.test.ts

@@ -0,0 +1,250 @@
+import { afterAll, beforeAll, describe, expect, it } from 'bun:test'
+import type { Wabe } from '../../server'
+import { type GraphQLClient, gql } from 'graphql-request'
+import { type DevWabeTypes, getGraphqlClient } from '../../utils/helper'
+import { setupTests, closeTests } from '../../utils/testHelper'
+
+describe('GraphQL : Scalars', () => {
+	let wabe: Wabe<DevWabeTypes>
+	let port: number
+	let client: GraphQLClient
+
+	const now = new Date()
+
+	beforeAll(async () => {
+		const setup = await setupTests()
+		wabe = setup.wabe
+		port = setup.port
+		client = getGraphqlClient(port)
+	})
+
+	afterAll(async () => {
+		await closeTests(wabe)
+	})
+
+	describe('Date', () => {
+		it('should create a date with JavaScript Date', async () => {
+			const { createUsers } = await client.request<any>(graphql.createUsers, {
+				input: {
+					fields: [
+						{
+							name: 'Jean',
+							birthDate: now,
+							email: 'email@test.fr',
+						},
+					],
+				},
+			})
+
+			expect(createUsers.edges[0].node.birthDate).toEqual(now.toISOString())
+		})
+
+		it('should create a date with timestamp in number', async () => {
+			const { createUsers } = await client.request<any>(graphql.createUsers, {
+				input: {
+					fields: [
+						{
+							name: 'Jean2',
+							birthDate: now.getTime(),
+							email: 'email@test.fr',
+						},
+					],
+				},
+			})
+
+			expect(createUsers.edges[0].node.birthDate).toEqual(now.toISOString())
+		})
+
+		it('should create a date with iso string', async () => {
+			const { createUsers } = await client.request<any>(graphql.createUsers, {
+				input: {
+					fields: [
+						{
+							name: 'Jean3',
+							birthDate: now.toISOString(),
+							email: 'email@test.fr',
+						},
+					],
+				},
+			})
+
+			expect(createUsers.edges[0].node.birthDate).toEqual(now.toISOString())
+		})
+
+		it('should create a date with partial date', async () => {
+			const { createUsers } = await client.request<any>(graphql.createUsers, {
+				input: {
+					fields: [
+						{
+							name: 'Jean4',
+							birthDate: '2023-12-20',
+							email: 'email@test.fr',
+						},
+					],
+				},
+			})
+
+			const birthDate = new Date(createUsers.edges[0].node.birthDate)
+			const date = new Date('2023-12-20')
+
+			expect(date.getFullYear()).toEqual(birthDate.getFullYear())
+			expect(date.getMonth()).toEqual(birthDate.getMonth())
+			expect(date.getDate()).toEqual(birthDate.getDate())
+		})
+
+		it('should not create a date with invalid string', () => {
+			expect(
+				client.request(graphql.createUsers, {
+					input: {
+						fields: [
+							{
+								name: 'Jean5',
+								birthDate: now.getTime().toString(),
+							},
+						],
+					},
+				}),
+			).rejects.toThrow('Invalid date')
+
+			expect(
+				client.request(graphql.createUsers, {
+					input: {
+						fields: [
+							{
+								name: 'Jean5',
+								birthDate: 'tata',
+							},
+						],
+					},
+				}),
+			).rejects.toThrow('Invalid date')
+		})
+	})
+
+	describe('Email', () => {
+		it('should create an email', async () => {
+			const { createUsers } = await client.request<any>(graphql.createUsers, {
+				input: {
+					fields: [
+						{
+							name: 'Jean',
+							email: 'jean.doe@gmail.com',
+						},
+					],
+				},
+			})
+
+			expect(createUsers.edges[0].node.email).toEqual('jean.doe@gmail.com')
+
+			expect(
+				client.request(graphql.createUsers, {
+					input: {
+						fields: [
+							{
+								name: 'Jean',
+								email: 'oe@gmail.com',
+							},
+						],
+					},
+				}),
+			).resolves.toEqual(expect.anything())
+
+			expect(
+				client.request(graphql.createUsers, {
+					input: {
+						fields: [
+							{
+								name: 'Jean',
+								email: 'test.@gmail.fr',
+							},
+						],
+					},
+				}),
+			).resolves.toEqual(expect.anything())
+		})
+
+		it('should not create an invalid email', () => {
+			expect(
+				client.request(graphql.createUsers, {
+					input: {
+						fields: [
+							{
+								name: 'Jean',
+								email: 'jean.doe',
+							},
+						],
+					},
+				}),
+			).rejects.toThrow('Invalid email')
+
+			expect(
+				client.request(graphql.createUsers, {
+					input: {
+						fields: [
+							{
+								name: 'Jean',
+								email: 'jean.doe@gmail',
+							},
+						],
+					},
+				}),
+			).rejects.toThrow('Invalid email')
+
+			expect(
+				client.request(graphql.createUsers, {
+					input: {
+						fields: [
+							{
+								name: 'Jean',
+								email: '@gmail.com',
+							},
+						],
+					},
+				}),
+			).rejects.toThrow('Invalid email')
+
+			expect(
+				client.request(graphql.createUsers, {
+					input: {
+						fields: [
+							{
+								name: 'Jean',
+								email: '@gmail',
+							},
+						],
+					},
+				}),
+			).rejects.toThrow('Invalid email')
+		})
+	})
+})
+
+const graphql = {
+	users: gql`
+		query users($where: UserWhereInput) {
+			users(where: $where) {
+				edges {
+					node {
+						id
+						name
+						birthDate
+						email
+					}
+				}
+			}
+		}
+	`,
+	createUsers: gql`
+		mutation createUsers($input: CreateUsersInput!) {
+			createUsers(input: $input) {
+				edges {
+					node {
+						name
+						birthDate
+						email
+					}
+				}
+			}
+		}
+	`,
+}

package/src/graphql/types.ts

@@ -0,0 +1,219 @@
+import {
+	GraphQLBoolean,
+	GraphQLFloat,
+	GraphQLInputObjectType,
+	GraphQLInt,
+	GraphQLList,
+	GraphQLScalarType,
+	GraphQLString,
+	GraphQLID,
+} from 'graphql'
+import { isValidPhoneNumber } from 'libphonenumber-js'
+import { tokenize } from '../utils'
+
+export const AnyScalarType = new GraphQLScalarType({
+	name: 'Any',
+	description:
+		'The Any scalar type is used in operations and types that involve any type of value.',
+	parseValue: (value) => value,
+	serialize: (value) => value,
+})
+
+export const DateScalarType = new GraphQLScalarType({
+	name: 'Date',
+	description: 'Date scalar type',
+	parseValue(value: any): Date {
+		const date = new Date(value)
+
+		if (Number.isNaN(date.getTime())) throw new Error('Invalid date')
+
+		return date
+	},
+	serialize(value: any) {
+		if (value instanceof Date) return value.toISOString()
+
+		return new Date(value).toISOString()
+	},
+})
+
+export const EmailScalarType = new GraphQLScalarType({
+	name: 'Email',
+	description: 'Email scalar type',
+	parseValue(value: any): string {
+		if (typeof value !== 'string') throw new Error('Invalid email')
+
+		if (!value.match(/^[^@\s]+@[^@\s]+\.[^@\s]+$/))
+			throw new Error('Invalid email')
+
+		return value
+	},
+})
+
+export const PhoneScalarType = new GraphQLScalarType({
+	name: 'Phone',
+	description: 'Phone scalar type',
+	parseValue(value: any): string {
+		if (typeof value !== 'string') throw new Error('Invalid phone')
+
+		if (!isValidPhoneNumber(value)) throw new Error('Invalid phone number')
+
+		return value
+	},
+})
+
+const parseFileValue = (value: any) => {
+	if (value instanceof Blob) return value
+
+	throw new Error('Invalid file')
+}
+
+export const FileScalarType = new GraphQLScalarType({
+	name: 'File',
+	description: 'File scalar type',
+	parseValue: parseFileValue,
+	serialize: (value: any) => {
+		return value
+	},
+	parseLiteral: () => {
+		throw new Error('Invalid file')
+	},
+})
+
+export const SearchScalarType = new GraphQLScalarType({
+	name: 'Search',
+	description: 'Search scalar to tokenize and search for all searchable fields',
+	parseValue: (value: any) => {
+		if (typeof value !== 'string') throw new Error('Invalid search term')
+
+		if (value === '') return ''
+
+		return tokenize(value).split(' ')
+	},
+})
+
+export const SearchWhereInput = new GraphQLInputObjectType({
+	name: 'SearchWhereInput',
+	fields: {
+		contains: { type: SearchScalarType },
+	},
+})
+
+export const AnyWhereInput = new GraphQLInputObjectType({
+	name: 'AnyWhereInput',
+	fields: {
+		equalTo: { type: AnyScalarType },
+		notEqualTo: { type: AnyScalarType },
+	},
+})
+
+export const FileWhereInput = new GraphQLInputObjectType({
+	name: 'FileWhereInput',
+	fields: {
+		equalTo: { type: FileScalarType },
+		notEqualTo: { type: FileScalarType },
+		in: { type: new GraphQLList(FileScalarType) },
+		notInt: { type: new GraphQLList(FileScalarType) },
+	},
+})
+
+export const ArrayWhereInput = new GraphQLInputObjectType({
+	name: 'ArrayWhereInput',
+	fields: {
+		equalTo: { type: AnyScalarType },
+		notEqualTo: { type: AnyScalarType },
+		contains: { type: AnyScalarType },
+		notContains: { type: AnyScalarType },
+	},
+})
+
+export const DateWhereInput = new GraphQLInputObjectType({
+	name: 'DateWhereInput',
+	fields: {
+		equalTo: { type: DateScalarType },
+		notEqualTo: { type: DateScalarType },
+		in: { type: new GraphQLList(DateScalarType) },
+		notIn: { type: new GraphQLList(DateScalarType) },
+		lessThan: { type: DateScalarType },
+		lessThanOrEqualTo: { type: DateScalarType },
+		greaterThan: { type: DateScalarType },
+		greaterThanOrEqualTo: { type: DateScalarType },
+	},
+})
+
+export const EmailWhereInput = new GraphQLInputObjectType({
+	name: 'EmailWhereInput',
+	fields: {
+		equalTo: { type: EmailScalarType },
+		notEqualTo: { type: EmailScalarType },
+		in: { type: new GraphQLList(EmailScalarType) },
+		notIn: { type: new GraphQLList(EmailScalarType) },
+	},
+})
+
+export const PhoneWhereInput = new GraphQLInputObjectType({
+	name: 'PhoneWhereInput',
+	fields: {
+		equalTo: { type: PhoneScalarType },
+		notEqualTo: { type: PhoneScalarType },
+		in: { type: new GraphQLList(PhoneScalarType) },
+		notIn: { type: new GraphQLList(PhoneScalarType) },
+	},
+})
+
+export const IdWhereInput = new GraphQLInputObjectType({
+	name: 'IdWhereInput',
+	fields: {
+		equalTo: { type: GraphQLID },
+		notEqualTo: { type: GraphQLID },
+		in: { type: new GraphQLList(GraphQLID) },
+		notIn: { type: new GraphQLList(GraphQLID) },
+	},
+})
+
+export const StringWhereInput = new GraphQLInputObjectType({
+	name: 'StringWhereInput',
+	fields: {
+		equalTo: { type: GraphQLString },
+		notEqualTo: { type: GraphQLString },
+		in: { type: new GraphQLList(GraphQLString) },
+		notIn: { type: new GraphQLList(GraphQLString) },
+	},
+})
+
+export const IntWhereInput = new GraphQLInputObjectType({
+	name: 'IntWhereInput',
+	fields: {
+		equalTo: { type: GraphQLInt },
+		notEqualTo: { type: GraphQLInt },
+		lessThan: { type: GraphQLInt },
+		lessThanOrEqualTo: { type: GraphQLInt },
+		greaterThan: { type: GraphQLInt },
+		greaterThanOrEqualTo: { type: GraphQLInt },
+		in: { type: new GraphQLList(GraphQLInt) },
+		notIn: { type: new GraphQLList(GraphQLInt) },
+	},
+})
+
+export const FloatWhereInput = new GraphQLInputObjectType({
+	name: 'FloatWhereInput',
+	fields: {
+		equalTo: { type: GraphQLFloat },
+		notEqualTo: { type: GraphQLFloat },
+		lessThan: { type: GraphQLFloat },
+		lessThanOrEqualTo: { type: GraphQLFloat },
+		greaterThan: { type: GraphQLFloat },
+		greaterThanOrEqualTo: { type: GraphQLFloat },
+		in: { type: new GraphQLList(GraphQLFloat) },
+		notIn: { type: new GraphQLList(GraphQLFloat) },
+	},
+})
+
+export const BooleanWhereInput = new GraphQLInputObjectType({
+	name: 'BooleanWhereInput',
+	fields: {
+		equalTo: { type: GraphQLBoolean },
+		notEqualTo: { type: GraphQLBoolean },
+		in: { type: new GraphQLList(GraphQLBoolean) },
+		notIn: { type: new GraphQLList(GraphQLBoolean) },
+	},
+})

package/src/hooks/HookObject.test.ts

@@ -0,0 +1,122 @@
+import { describe, expect, it, beforeAll, afterAll } from 'bun:test'
+import { HookObject } from './HookObject'
+import { OperationType } from '.'
+import type { DevWabeTypes } from '../utils/helper'
+import { setupTests, closeTests } from '../utils/testHelper'
+import type { Wabe } from '../server'
+
+describe('HookObject', () => {
+	let wabe: Wabe<DevWabeTypes>
+
+	beforeAll(async () => {
+		const setup = await setupTests()
+		wabe = setup.wabe
+	})
+
+	afterAll(async () => {
+		await closeTests(wabe)
+	})
+
+	it('should fetch all the fields of an object', async () => {
+		const res = await wabe.controllers.database.createObject({
+			className: 'User',
+			data: { age: 30, name: 'John Doe' },
+			context: {
+				wabe,
+				isRoot: true,
+			},
+			select: { id: true },
+		})
+
+		const hookObject = new HookObject<DevWabeTypes, 'User'>({
+			className: 'User',
+			// @ts-expect-error
+			newData: { age: 30, name: 'John Doe' },
+			context: {
+				wabe,
+			} as any,
+			operationType: OperationType.BeforeCreate,
+			object: {
+				id: res?.id || 'id',
+			},
+			select: {},
+		})
+
+		const fetchResult = await hookObject.fetch()
+
+		expect(fetchResult).toEqual(
+			expect.objectContaining({
+				id: res?.id || 'id',
+				age: 30,
+				name: 'John Doe',
+			}),
+		)
+	})
+
+	it('should return correctly value depends on the update state of the field', () => {
+		const userData = { name: 'John Doe' }
+
+		const hookObject = new HookObject<DevWabeTypes, 'User'>({
+			className: 'User',
+			// @ts-expect-error
+			newData: userData,
+			context: {} as any,
+			operationType: OperationType.BeforeUpdate,
+			object: {
+				id: '1',
+			},
+			select: {},
+		})
+
+		expect(hookObject.isFieldUpdated('name')).toBeTrue()
+		expect(hookObject.isFieldUpdated('age')).toBeFalse()
+	})
+
+	it('should create a clone of the data', () => {
+		const userData = { name: 'John Doe', age: 30 }
+
+		const hookObject = new HookObject<DevWabeTypes, 'User'>({
+			className: 'User',
+			newData: userData as any,
+			operationType: OperationType.BeforeCreate,
+			context: {} as any,
+			object: {
+				id: '1',
+			},
+			select: {},
+		})
+
+		hookObject.upsertNewData('name', 'tata')
+
+		expect(hookObject.getNewData()).toEqual(
+			expect.objectContaining({
+				name: 'tata',
+				age: 30,
+			}),
+		)
+	})
+
+	it('should not set data for an after hook', () => {
+		const userData = { name: 'John Doe', age: 30 }
+
+		const hookObject = new HookObject({
+			className: 'User',
+			newData: userData as any,
+			operationType: OperationType.AfterCreate,
+			context: {} as any,
+			object: {
+				id: '1',
+			},
+			select: {},
+		})
+
+		expect(() => hookObject.upsertNewData('name', 'tata')).toThrow(
+			'Cannot set data in a hook that is not a before hook',
+		)
+
+		expect(hookObject.getNewData()).toEqual({
+			name: 'John Doe',
+			age: 30,
+		})
+	})
+})