wabe 0.6.12 → 0.6.14

package/src/utils/database.ts

@@ -1,8 +0,0 @@
-import type { WabeTypes } from '../server'
-import type { WabeContext } from '../server/interface'
-
-export const getDatabaseController = <T extends WabeTypes>(context: WabeContext<T>) => {
-	const databaseController = context.wabe.controllers?.database
-	if (!databaseController) throw new Error('No database controller found')
-	return databaseController
-}

package/src/utils/export.ts

@@ -1,12 +0,0 @@
-import type { WabeContext } from '../server/interface'
-
-export const contextWithRoot = (context: WabeContext<any>): WabeContext<any> => ({
-	...context,
-	isRoot: true,
-})
-
-export const notEmpty = <T>(value: T | null | undefined): value is T =>
-	value !== null && value !== undefined
-
-export * from './crypto'
-export * from './database'

package/src/utils/helper.ts

@@ -1,204 +0,0 @@
-import { gql, GraphQLClient } from 'graphql-request'
-import {
-	RoleEnum,
-	type WabeSchemaWhereTypes,
-	type WabeSchemaEnums,
-	type WabeSchemaScalars,
-	type WabeSchemaTypes,
-} from '../../generated/wabe'
-import type { Wabe, WabeTypes } from '../server'
-import { defaultPrivateFields } from 'src/schema'
-
-export interface DevWabeTypes extends WabeTypes {
-	types: WabeSchemaTypes
-	scalars: WabeSchemaScalars
-	enums: WabeSchemaEnums
-	where: WabeSchemaWhereTypes
-}
-
-export const selectFieldsWithoutPrivateFields = <T extends Record<string, any>>(select?: T): T =>
-	Object.entries(select || {}).reduce((acc, [key, value]) => {
-		if (defaultPrivateFields.includes(key)) return acc
-
-		return {
-			...acc,
-			[key]: value,
-		}
-	}, {} as T)
-
-export const firstLetterUpperCase = (str: string): string =>
-	str.charAt(0).toUpperCase() + str.slice(1)
-
-export const getGraphqlClient = (port: number): GraphQLClient => {
-	const client = new GraphQLClient(`http://127.0.0.1:${port}/graphql`, {
-		headers: {
-			'Wabe-Root-Key': 'dev',
-		},
-	})
-
-	return { ...client, request: client.request<any> } as GraphQLClient
-}
-
-export const getAnonymousClient = (port: number): GraphQLClient => {
-	const client = new GraphQLClient(`http://127.0.0.1:${port}/graphql`)
-
-	return { ...client, request: client.request<any> } as GraphQLClient
-}
-
-export const getUserClient = (
-	port: number,
-	options: {
-		accessToken?: string
-		csrfToken?: string
-	},
-): GraphQLClient => {
-	const client = new GraphQLClient(`http://127.0.0.1:${port}/graphql`, {
-		headers: {
-			'Wabe-Access-Token': options.accessToken || '',
-			'Wabe-Csrf-Token': options.csrfToken || '',
-		},
-	})
-
-	return { ...client, request: client.request<any> } as GraphQLClient
-}
-
-export const getAdminUserClient = async (
-	port: number,
-	wabe: Wabe<DevWabeTypes>,
-	{ email, password }: { email: string; password: string },
-): Promise<GraphQLClient> => {
-	const roles = await wabe.controllers.database.getObjects({
-		className: 'Role',
-		context: {
-			isRoot: true,
-			wabe,
-		} as any,
-		select: { id: true },
-		where: {
-			name: { equalTo: RoleEnum.Admin },
-		},
-	})
-
-	const adminRoleId = roles[0]?.id
-
-	const res = await getGraphqlClient(port).request<any>(
-		gql`
-			mutation signUpWith($input: SignUpWithInput!) {
-				signUpWith(input: $input) {
-					id
-					accessToken
-				}
-			}
-		`,
-		{
-			input: {
-				authentication: {
-					emailPassword: {
-						email,
-						password,
-					},
-				},
-			},
-		},
-	)
-
-	const accessToken = res.signUpWith.accessToken
-	const userId = res.signUpWith.id
-
-	await wabe.controllers.database.updateObjects({
-		className: 'User',
-		context: {
-			isRoot: true,
-			wabe,
-		} as any,
-		data: {
-			role: adminRoleId,
-		},
-		select: {},
-		where: {
-			id: { equalTo: userId },
-		},
-	})
-
-	const client = new GraphQLClient(`http://127.0.0.1:${port}/graphql`, {
-		headers: {
-			'Wabe-Access-Token': accessToken,
-		},
-	})
-
-	return { ...client, request: client.request<any> } as GraphQLClient
-}
-
-export const createUserAndUpdateRole = async ({
-	anonymousClient,
-	rootClient,
-	roleName,
-	port,
-	email,
-}: {
-	port: number
-	anonymousClient: GraphQLClient
-	rootClient: GraphQLClient
-	roleName: string
-	email?: string
-}) => {
-	const random = Math.random().toString(36).substring(2)
-
-	const res = await anonymousClient.request<any>(
-		gql`
-			mutation signUpWith($input: SignUpWithInput!) {
-				signUpWith(input: $input) {
-					id
-					accessToken
-					refreshToken
-				}
-			}
-		`,
-		{
-			input: {
-				authentication: {
-					emailPassword: {
-						email: email || `email${random}@test.fr`,
-						password: 'password',
-					},
-				},
-			},
-		},
-	)
-
-	const resOfRoles = await rootClient.request<any>(gql`
-			query getRoles {
-					roles(where: {name: {equalTo: "${roleName}"}}) {
-			    edges {
-		    			node {
-		     			 	id
-		    			}
-		  			}
-					}
-			}
-		`)
-
-	const roleId = resOfRoles.roles.edges[0].node.id
-
-	await rootClient.request<any>(gql`
-			mutation updateUser {
-			  updateUser(input: {id: "${res.signUpWith.id}", fields: {role: {link: "${roleId}"}}}) {
-		  			user {
-		    			id
-		  			}
-					}
-			}
-		`)
-
-	const userClient = getUserClient(port, {
-		accessToken: res.signUpWith.accessToken,
-	})
-
-	return {
-		userClient,
-		roleId,
-		userId: res.signUpWith.id,
-		refreshToken: res.signUpWith.refreshToken,
-		accessToken: res.signUpWith.accessToken,
-	}
-}

package/src/utils/index.test.ts

@@ -1,11 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { firstLetterInLowerCase } from '.'
-
-describe('utils', () => {
-	it('should put the first letter in lowercase', () => {
-		expect(firstLetterInLowerCase('Hello')).toEqual('hello')
-		expect(firstLetterInLowerCase('User')).toEqual('user')
-		expect(firstLetterInLowerCase('USer')).toEqual('uSer')
-		expect(firstLetterInLowerCase('99 User')).toEqual('99 user')
-	})
-})

package/src/utils/index.ts

@@ -1,196 +0,0 @@
-import { timingSafeEqual } from 'node:crypto'
-import type { ClassInterface } from '../schema'
-import type { WabeTypes, WabeConfig, WabeContext } from '../server'
-
-export const isValidRootKey = (headers: Headers, rootKey: string): boolean => {
-	const headerRootKey = Buffer.from(headers.get('Wabe-Root-Key') || '')
-	const key = Buffer.from(rootKey)
-	return headerRootKey.length === key.length && timingSafeEqual(key, headerRootKey)
-}
-
-export const contextWithoutGraphQLCall = (context: WabeContext<any>): WabeContext<any> => ({
-	...context,
-	isGraphQLCall: false,
-})
-
-const RFC4648 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'
-const RFC4648_HEX = '0123456789ABCDEFGHIJKLMNOPQRSTUV'
-const CROCKFORD = '0123456789ABCDEFGHJKMNPQRSTVWXYZ'
-
-type Base32Variant = 'RFC3548' | 'RFC4648' | 'RFC4648-HEX' | 'Crockford'
-
-interface Base32Options {
-	padding?: boolean
-}
-
-/**
- * Convert supported input types to Uint8Array.
- */
-export const toUint8Array = (data: string | ArrayBuffer | Uint8Array | Buffer): Uint8Array => {
-	if (data instanceof Uint8Array) return data
-
-	if (typeof data === 'string') {
-		const encoder = new TextEncoder()
-		return encoder.encode(data)
-	}
-
-	if (data instanceof ArrayBuffer) return new Uint8Array(data)
-
-	throw new TypeError('Unsupported data type for base32 encoding')
-}
-
-/**
- * Encode binary data to base32 using specified variant.
- * Base on https://github.com/LinusU/base32-encode/blob/master/index.js
- */
-export const base32Encode = (
-	data: string | ArrayBuffer | Uint8Array | Buffer,
-	variant: Base32Variant,
-	options: Base32Options = {},
-): string => {
-	let alphabet: string
-	let defaultPadding: boolean
-
-	switch (variant) {
-		case 'RFC3548':
-		case 'RFC4648':
-			alphabet = RFC4648
-			defaultPadding = true
-			break
-		case 'RFC4648-HEX':
-			alphabet = RFC4648_HEX
-			defaultPadding = true
-			break
-		case 'Crockford':
-			alphabet = CROCKFORD
-			defaultPadding = false
-			break
-		default:
-			throw new Error(`Unknown base32 variant: ${variant}`)
-	}
-
-	const padding = options.padding !== undefined ? options.padding : defaultPadding
-	const view = toUint8Array(data)
-
-	let bits = 0
-	let value = 0
-	let output = ''
-
-	for (let i = 0; i < view.length; i++) {
-		// @ts-expect-error
-		value = (value << 8) | view[i]
-		bits += 8
-
-		while (bits >= 5) {
-			output += alphabet[(value >>> (bits - 5)) & 31]
-			bits -= 5
-		}
-	}
-
-	if (bits > 0) {
-		output += alphabet[(value << (5 - bits)) & 31]
-	}
-
-	if (padding) {
-		while (output.length % 8 !== 0) {
-			output += '='
-		}
-	}
-
-	return output
-}
-
-export const getNewObjectAfterUpdateNestedProperty = (obj: any, path: string, value: any) => {
-	const keys = path.split('.')
-	let current = { ...obj }
-
-	for (let i = 0; i < keys.length - 1; i++) {
-		const key = keys[i]
-
-		if (!key) continue
-
-		if (current[key] === undefined) {
-			current[key] = {}
-		}
-		current = current[key]
-	}
-
-	// @ts-expect-error
-	current[keys[keys.length - 1]] = value
-	return obj
-}
-
-export const getNestedProperty = (obj: any, path: string) => {
-	return path.split('.').reduce((acc, part) => acc?.[part], obj)
-}
-
-export const firstLetterInUpperCase = (str: string) => {
-	const indexOfFirstLetter = str.search(/[a-z]/i)
-
-	return (
-		str.slice(0, indexOfFirstLetter) +
-		str[indexOfFirstLetter]?.toUpperCase() +
-		str.slice(indexOfFirstLetter + 1)
-	)
-}
-
-export const firstLetterInLowerCase = (str: string) => {
-	const indexOfFirstLetter = str.search(/[a-z]/i)
-
-	return (
-		str.slice(0, indexOfFirstLetter) +
-		str[indexOfFirstLetter]?.toLowerCase() +
-		str.slice(indexOfFirstLetter + 1)
-	)
-}
-
-export const getClassFromClassName = <T extends WabeTypes>(
-	className: string,
-	config: WabeConfig<any>,
-): ClassInterface<T> => {
-	const classInSchema = config.schema?.classes?.find(
-		(schemaClass) => schemaClass.name === className,
-	)
-
-	if (!classInSchema) throw new Error('Class not found in schema')
-
-	return classInSchema
-}
-
-// TODO: Put this in wobe
-export const getCookieInRequestHeaders = (cookieName: string, headers: Headers) => {
-	const cookies = headers.get('Cookie')
-
-	if (!cookies) return
-
-	const cookie = cookies.split(';').find((c) => c.includes(cookieName))
-
-	if (!cookie) return
-
-	return cookie.split('=')[1]
-}
-
-/**
- * This apply the following transformations on string:
- * - lowercase
- * - normalize with NFD
- * - remove diacritics and accents characters
- * - replace matching abbreviation with long version (if disableAbbreviations is not set)
- * - replace 2 or more spaces by one
- * - replace all non alpha characters by a space
- * - trim
- */
-export const tokenize = (value: string) => {
-	const tmpValue = value
-		.toLowerCase()
-		.normalize('NFD')
-		.replace(/[\u0300-\u036f]/g, '')
-		.replace(/\s\s+/g, ' ')
-
-	return (
-		tmpValue
-			// Replace all non alpha
-			.replace(/[\W_]+/g, ' ')
-			.trim()
-	)
-}

package/src/utils/preload.ts

@@ -1,8 +0,0 @@
-import { runDatabase } from 'wabe-mongodb-launcher'
-
-const setupEnvironment = () => {
-	process.env.TEST = 'true'
-}
-
-await runDatabase()
-setupEnvironment()

package/src/utils/testHelper.ts

@@ -1,124 +0,0 @@
-import { v4 as uuid } from 'uuid'
-import type { RateLimitOptions } from 'wobe'
-import { type ClassInterface, EmailDevAdapter, FileDevAdapter } from '..'
-import { Wabe } from '../server'
-import type { DevWabeTypes } from './helper'
-import getPort from 'get-port'
-
-export const getDatabaseAdapter = async (databaseName: string) => {
-	const mongodbAdapter = await import('wabe-mongodb')
-
-	return new mongodbAdapter.MongoAdapter<DevWabeTypes>({
-		// For postgres
-		// databaseUrl: 'postgresql://wabe:wabe@localhost:5432',
-		databaseUrl: 'mongodb://localhost:27045',
-		databaseName,
-	})
-}
-
-export const setupTests = async (
-	additionalClasses: ClassInterface<any>[] = [],
-	options: {
-		isProduction?: boolean
-		disableCSRFProtection?: boolean
-		disableIntrospection?: boolean
-		rootKey?: string
-		rateLimit?: RateLimitOptions
-	} = {},
-) => {
-	const databaseId = uuid()
-
-	const port = await getPort()
-
-	const wabe = new Wabe<DevWabeTypes>({
-		isProduction: !!options.isProduction,
-		rootKey: options.rootKey ?? 'dev',
-		database: {
-			// @ts-expect-error
-			adapter: await getDatabaseAdapter(databaseId),
-		},
-		security: {
-			// To make test easier keep default value to true
-			disableCSRFProtection: options.disableCSRFProtection ?? true,
-			...(options.disableIntrospection !== undefined && {
-				disableIntrospection: options.disableIntrospection,
-			}),
-			...(options.rateLimit && { rateLimit: options.rateLimit }),
-		},
-		authentication: {
-			roles: ['Client', 'Client2', 'Client3', 'Admin'],
-			session: {
-				jwtSecret: 'dev',
-				cookieSession: true,
-			},
-		},
-		port,
-		email: {
-			adapter: new EmailDevAdapter(),
-			mainEmail: 'main.email@wabe.com',
-		},
-		file: {
-			adapter: new FileDevAdapter(),
-			// 12 hours of cache
-			urlCacheInSeconds: 3600 * 12,
-		},
-		schema: {
-			classes: [
-				...additionalClasses,
-				{
-					name: 'User',
-					fields: {
-						name: { type: 'String' },
-						age: { type: 'Int' },
-						isAdmin: { type: 'Boolean', defaultValue: false },
-						floatValue: { type: 'Float' },
-						birthDate: { type: 'Date' },
-						arrayValue: {
-							type: 'Array',
-							typeValue: 'String',
-						},
-						test: { type: 'TestScalar' },
-					},
-					searchableFields: ['email'],
-					permissions: {
-						create: {
-							requireAuthentication: false,
-						},
-						delete: {
-							requireAuthentication: true,
-						},
-						update: {
-							requireAuthentication: false,
-						},
-						read: {
-							requireAuthentication: false,
-						},
-						acl: async (hookObject) => {
-							await hookObject.addACL('users', {
-								userId: hookObject.object?.id,
-								read: true,
-								write: true,
-							})
-
-							await hookObject.addACL('roles', null)
-						},
-					},
-				},
-			],
-			scalars: [
-				{
-					name: 'TestScalar',
-					description: 'Test scalar',
-				},
-			],
-		},
-	})
-
-	await wabe.start()
-
-	return { wabe, port }
-}
-
-export const closeTests = async (wabe: Wabe<DevWabeTypes>) => {
-	await wabe.close()
-}

package/tsconfig.json

@@ -1,32 +0,0 @@
-{
-	"compilerOptions": {
-		// Environment setup & latest features
-		"lib": ["ESNext"],
-		"target": "ESNext",
-		"module": "Preserve",
-		"moduleDetection": "force",
-		"jsx": "react-jsx",
-		"allowJs": true,
-
-		// Bundler mode
-		"moduleResolution": "bundler",
-		"allowImportingTsExtensions": true,
-		"verbatimModuleSyntax": false,
-		"noEmit": true,
-
-		// Best practices
-		"strict": true,
-		"skipLibCheck": true,
-		"noFallthroughCasesInSwitch": true,
-		"noUncheckedIndexedAccess": true,
-		"noImplicitOverride": true,
-
-		// Some stricter flags (disabled by default)
-		"noUnusedLocals": false,
-		"noUnusedParameters": false,
-		"noPropertyAccessFromIndexSignature": false,
-		"baseUrl": "."
-	},
-	"exclude": ["node_modules", "dist", "generated"],
-	"include": ["src/**/*.ts", "dev/**/*.ts"]
-}