Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.
JavaScript 3d-generationai-agentsanimationavatardigital-humangenerative-aiglbgltfimage-to-3dllmmcpmcp-servermodel-context-protocolsolanatext-to-3dthreejsweb-componentswebglwebxrx402
import { describe, it, expect } from 'vitest';
import {
email,
password,
displayName,
slug,
avatarVisibility,
avatarContentType,
username,
registerBody,
loginBody,
createAvatarBody,
presignUploadBody,
parse,
} from '../../api/_lib/validate.js';
describe('email schema', () => {
it('accepts valid email', () => {
expect(email.parse('[email protected]')).toBe('[email protected]');
});
it('trims whitespace and lowercases', () => {
expect(email.parse(' [email protected] ')).toBe('[email protected]');
});
it('rejects invalid email', () => {
expect(() => email.parse('not-an-email')).toThrow();
});
it('rejects email over 254 chars', () => {
const long = 'a'.repeat(244) + '@example.com';
expect(() => email.parse(long)).toThrow();
});
});
describe('password schema', () => {
it('accepts 10-char password', () => {
expect(password.parse('1234567890')).toBe('1234567890');
});
it('rejects password under 10 chars', () => {
expect(() => password.parse('short')).toThrow();
});
it('rejects password over 200 chars', () => {
expect(() => password.parse('a'.repeat(201))).toThrow();
});
});
describe('displayName schema', () => {
it('accepts valid display name', () => {
expect(displayName.parse(' Alice ')).toBe('Alice');
});
it('rejects empty string', () => {
expect(() => displayName.parse('')).toThrow();
});
it('rejects name over 80 chars', () => {
expect(() => displayName.parse('a'.repeat(81))).toThrow();
});
});
describe('slug schema', () => {
it('accepts valid slugs', () => {
expect(slug.parse('my-avatar')).toBe('my-avatar');
expect(slug.parse('avatar_1')).toBe('avatar_1');
expect(slug.parse('abc123')).toBe('abc123');
});
it('rejects slugs starting with - or _', () => {
expect(() => slug.parse('-bad')).toThrow();
expect(() => slug.parse('_bad')).toThrow();
});
it('rejects uppercase letters', () => {
expect(() => slug.parse('MyAvatar')).toThrow();
});
it('rejects empty string', () => {
expect(() => slug.parse('')).toThrow();
});
it('rejects slug over 64 chars', () => {
expect(() => slug.parse('a'.repeat(65))).toThrow();
});
});
describe('avatarVisibility schema', () => {
it('accepts valid values', () => {
expect(avatarVisibility.parse('private')).toBe('private');
expect(avatarVisibility.parse('unlisted')).toBe('unlisted');
expect(avatarVisibility.parse('public')).toBe('public');
});
it('rejects unknown values', () => {
expect(() => avatarVisibility.parse('hidden')).toThrow();
});
});
describe('avatarContentType schema', () => {
it('accepts GLB content type', () => {
expect(avatarContentType.parse('model/gltf-binary')).toBe('model/gltf-binary');
});
it('accepts GLTF content type', () => {
expect(avatarContentType.parse('model/gltf+json')).toBe('model/gltf+json');
});
it('rejects other content types', () => {
expect(() => avatarContentType.parse('image/png')).toThrow();
expect(() => avatarContentType.parse('text/html')).toThrow();
});
});
describe('username schema', () => {
it('accepts valid usernames', () => {
expect(username.parse('alice_123')).toBe('alice_123');
expect(username.parse('Bob-42')).toBe('Bob-42');
});
it('rejects username under 3 chars', () => {
expect(() => username.parse('ab')).toThrow();
});
it('rejects username over 30 chars', () => {
expect(() => username.parse('a'.repeat(31))).toThrow();
});
it('rejects special characters', () => {
expect(() => username.parse('user@name')).toThrow();
expect(() => username.parse('user name')).toThrow();
});
});
describe('registerBody schema', () => {
it('accepts valid registration body', () => {
const result = registerBody.parse({
email: '[email protected]',
password: 'securepassword1',
});
expect(result.email).toBe('[email protected]');
expect(result.password).toBe('securepassword1');
});
it('accepts optional display_name', () => {
const result = registerBody.parse({
email: '[email protected]',
password: 'securepassword1',
display_name: 'Alice',
});
expect(result.display_name).toBe('Alice');
});
it('rejects missing email', () => {
expect(() => registerBody.parse({ password: 'securepassword1' })).toThrow();
});
});
describe('loginBody schema', () => {
it('accepts email + password', () => {
const result = loginBody.parse({ email: '[email protected]', password: 'pass' });
expect(result.email).toBe('[email protected]');
});
it('rejects empty password', () => {
expect(() => loginBody.parse({ email: '[email protected]', password: '' })).toThrow();
});
});
describe('createAvatarBody schema', () => {
const base = { name: 'My Avatar', size_bytes: 1024 };
it('accepts minimal valid body with defaults', () => {
const result = createAvatarBody.parse(base);
expect(result.name).toBe('My Avatar');
expect(result.visibility).toBe('private');
expect(result.tags).toEqual([]);
expect(result.source).toBe('upload');
expect(result.content_type).toBe('model/gltf-binary');
});
it('rejects size_bytes over 500MB', () => {
expect(() =>
createAvatarBody.parse({ ...base, size_bytes: 500 * 1024 * 1024 + 1 }),
).toThrow();
});
it('rejects invalid checksum format', () => {
expect(() => createAvatarBody.parse({ ...base, checksum_sha256: 'not-a-hash' })).toThrow();
});
it('accepts valid 64-char hex checksum', () => {
const result = createAvatarBody.parse({
...base,
checksum_sha256: 'a'.repeat(64),
});
expect(result.checksum_sha256).toBe('a'.repeat(64));
});
});
describe('parse helper', () => {
it('returns parsed data on success', () => {
const result = parse(email, '[email protected]');
expect(result).toBe('[email protected]');
});
it('throws error with status 400 and code validation_error on failure', () => {
let err;
try {
parse(email, 'not-an-email');
} catch (e) {
err = e;
}
expect(err).toBeDefined();
expect(err.status).toBe(400);
expect(err.code).toBe('validation_error');
expect(err.message).toBeTruthy();
});
it('includes field path in error message', () => {
let err;
try {
parse(registerBody, { email: 'bad', password: 'short' });
} catch (e) {
err = e;
}
expect(err.message).toMatch(/email|password/i);
});
});