wabe 0.6.9 → 0.6.10

package/src/utils/crypto.ts

@@ -0,0 +1,121 @@
+import {
+	randomBytes,
+	createCipheriv,
+	createDecipheriv,
+	createHmac,
+} from 'node:crypto'
+import { promisify } from 'node:util'
+
+const params = {
+	parallelism: 1,
+	tagLength: 64,
+	memory: 65536,
+	passes: 2,
+}
+
+/*
+ * Hash a string with Argon2id and PHC format
+ * @return : Returns the PHC format of the hashed text
+ */
+export const hashArgon2 = async (text: string) => {
+	if (process.versions.bun)
+		return Bun.password.hash(text, { algorithm: 'argon2id' })
+
+	// Node support
+	const argon2 = promisify(require('node:crypto').argon2)
+
+	const nonce = randomBytes(16)
+
+	const result = await argon2('argon2id', {
+		message: text,
+		nonce,
+		...params,
+	})
+
+	return `$argon2id$v=19$m=${params.memory},t=${params.passes},p=${params.parallelism}$${nonce.toString('base64').replace(/=+$/, '')}$${result.toString('base64').replace(/=+$/, '')}`
+}
+
+/*
+ * Verify if a hash matchs with a string
+ * @return : Returns true if the password matchs with the hash, false otherwise
+ */
+export const verifyArgon2 = async (password: string, hash: string) => {
+	if (process.versions.bun)
+		return Bun.password.verify(password, hash, 'argon2id')
+
+	// Node support
+	const [, algorithm, , paramString, nonceHex, storedHashHex] = hash.split('$')
+
+	const kvPairs = paramString?.split(',')
+	const parsedParams = Object.fromEntries(
+		kvPairs?.map((pair) => {
+			const [key, value] = pair.split('=')
+			return [key, Number.parseInt(value || '', 10)]
+		}) || [],
+	)
+
+	const memory = parsedParams.m
+	const passes = parsedParams.t
+	const parallelism = parsedParams.p
+
+	const newDerived = await promisify(require('node:crypto'))(algorithm, {
+		nonce: Buffer.from(nonceHex || '', 'base64'),
+		parallelism,
+		tagLength: 64,
+		memory,
+		passes,
+		message: password,
+	})
+
+	const isMatch = crypto.timingSafeEqual(
+		Buffer.from(newDerived),
+		Buffer.from(storedHashHex || '', 'base64'),
+	)
+
+	return isMatch
+}
+
+export const isArgon2Hash = (value: string): boolean =>
+	typeof value === 'string' && value.startsWith('$argon2')
+
+/**
+ * Deterministic AES-256-GCM encryption for tokens.
+ * IV is derived via HMAC-SHA256(key, token) to allow equality checks without storing plaintext.
+ * Caller must provide a strong 32-byte key (already derived/hashed).
+ */
+export const encryptDeterministicToken = (
+	token: string,
+	key: Buffer,
+): string => {
+	const iv = createHmac('sha256', key).update(token).digest().subarray(0, 12)
+	const cipher = createCipheriv('aes-256-gcm', key, iv)
+	const encrypted = Buffer.concat([
+		cipher.update(token, 'utf8'),
+		cipher.final(),
+	])
+	const tag = cipher.getAuthTag()
+	return `${iv.toString('hex')}:${tag.toString('hex')}:${encrypted.toString('hex')}`
+}
+
+export const decryptDeterministicToken = (
+	encryptedToken: string | undefined,
+	key: Buffer,
+): string | null => {
+	if (!encryptedToken) return null
+	const [ivHex, tagHex, valueHex] = encryptedToken.split(':')
+	if (!ivHex || !tagHex || !valueHex) return null
+	try {
+		const iv = Buffer.from(ivHex, 'hex')
+		const tag = Buffer.from(tagHex, 'hex')
+		const encryptedValue = Buffer.from(valueHex, 'hex')
+		const decipher = createDecipheriv('aes-256-gcm', key, iv)
+		decipher.setAuthTag(tag)
+		const decrypted = Buffer.concat([
+			decipher.update(encryptedValue),
+			decipher.final(),
+		])
+		return decrypted.toString('utf8')
+	} catch {
+		return null
+	}
+}

package/src/utils/export.ts

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

package/src/utils/helper.ts

@@ -0,0 +1,195 @@
+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'
+
+export interface DevWabeTypes extends WabeTypes {
+	types: WabeSchemaTypes
+	scalars: WabeSchemaScalars
+	enums: WabeSchemaEnums
+	where: WabeSchemaWhereTypes
+}
+
+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
+		csrfToken
+      }
+    }
+  `,
+		{
+			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,
+		csrfToken: res.signUpWith.csrfToken,
+	}
+}

package/src/utils/index.test.ts

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

@@ -0,0 +1,201 @@
+import type { ClassInterface } from '../schema'
+import type { WabeTypes, WabeConfig, WabeContext } from '../server'
+
+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

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

package/src/utils/testHelper.ts

@@ -0,0 +1,117 @@
+import { v4 as uuid } from 'uuid'
+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
+	} = {},
+) => {
+	const databaseId = uuid()
+
+	const port = await getPort()
+
+	const wabe = new Wabe<DevWabeTypes>({
+		isProduction: !!options.isProduction,
+		rootKey: 'dev',
+		database: {
+			// @ts-expect-error
+			adapter: await getDatabaseAdapter(databaseId),
+		},
+		security: {
+			// To make test easier keep default value to true
+			disableCSRFProtection: options.disableCSRFProtection ?? true,
+		},
+		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.controllers.database.adapter?.close()
+	await wabe.close()
+}

package/tsconfig.json

@@ -0,0 +1,32 @@
+{
+	"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"]
+}

package/bunfig.toml

@@ -1,4 +0,0 @@
-telemetry = false
-
-[test]
-preload = ['./src/utils/preload.ts']

package/dist/ai/index.d.ts

@@ -1 +0,0 @@
-export * from "./interface";