wabe 0.6.12 → 0.6.14

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

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

@@ -1,227 +0,0 @@
-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 },
-		exists: { type: GraphQLBoolean },
-	},
-})
-
-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 },
-		exists: { type: GraphQLBoolean },
-	},
-})
-
-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 },
-		exists: { type: GraphQLBoolean },
-	},
-})
-
-export const EmailWhereInput = new GraphQLInputObjectType({
-	name: 'EmailWhereInput',
-	fields: {
-		equalTo: { type: EmailScalarType },
-		notEqualTo: { type: EmailScalarType },
-		in: { type: new GraphQLList(EmailScalarType) },
-		notIn: { type: new GraphQLList(EmailScalarType) },
-		exists: { type: GraphQLBoolean },
-	},
-})
-
-export const PhoneWhereInput = new GraphQLInputObjectType({
-	name: 'PhoneWhereInput',
-	fields: {
-		equalTo: { type: PhoneScalarType },
-		notEqualTo: { type: PhoneScalarType },
-		in: { type: new GraphQLList(PhoneScalarType) },
-		notIn: { type: new GraphQLList(PhoneScalarType) },
-		exists: { type: GraphQLBoolean },
-	},
-})
-
-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) },
-		exists: { type: GraphQLBoolean },
-	},
-})
-
-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) },
-		exists: { type: GraphQLBoolean },
-	},
-})
-
-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) },
-		exists: { type: GraphQLBoolean },
-	},
-})
-
-export const BooleanWhereInput = new GraphQLInputObjectType({
-	name: 'BooleanWhereInput',
-	fields: {
-		equalTo: { type: GraphQLBoolean },
-		notEqualTo: { type: GraphQLBoolean },
-		in: { type: new GraphQLList(GraphQLBoolean) },
-		notIn: { type: new GraphQLList(GraphQLBoolean) },
-		exists: { type: GraphQLBoolean },
-	},
-})

package/src/hooks/HookObject.test.ts

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