@getmicdrop/svelte-components 5.17.3 → 5.17.4

package/dist/schemas/__tests__/order.test.js

@@ -0,0 +1,349 @@
+import { describe, expect, it } from 'vitest';
+import { boxOfficeCheckoutSchema, checkoutSchema, customerInfoSchema, orderFilterSchema, orderNoteSchema, orderResendSchema, orderStatusSchema, paymentMethodSchema, refundRequestSchema, } from '../order';
+describe('orderStatusSchema', () => {
+    it('accepts valid statuses', () => {
+        const statuses = [
+            'pending',
+            'processing',
+            'completed',
+            'cancelled',
+            'refunded',
+            'partially_refunded',
+        ];
+        statuses.forEach(status => {
+            const result = orderStatusSchema.safeParse(status);
+            expect(result.success).toBe(true);
+        });
+    });
+    it('rejects invalid status', () => {
+        const result = orderStatusSchema.safeParse('invalid');
+        expect(result.success).toBe(false);
+    });
+});
+describe('paymentMethodSchema', () => {
+    it('accepts valid payment methods', () => {
+        const methods = ['credit_card', 'apple_pay', 'google_pay', 'cash'];
+        methods.forEach(method => {
+            const result = paymentMethodSchema.safeParse(method);
+            expect(result.success).toBe(true);
+        });
+    });
+    it('rejects invalid payment method', () => {
+        const result = paymentMethodSchema.safeParse('bitcoin');
+        expect(result.success).toBe(false);
+    });
+});
+describe('customerInfoSchema', () => {
+    it('accepts valid customer info', () => {
+        const result = customerInfoSchema.safeParse({
+            firstName: 'John',
+            lastName: 'Doe',
+            email: 'john@example.com',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts customer with phone', () => {
+        const result = customerInfoSchema.safeParse({
+            firstName: 'John',
+            lastName: 'Doe',
+            email: 'john@example.com',
+            phone: '555-123-4567',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects missing first name', () => {
+        const result = customerInfoSchema.safeParse({
+            lastName: 'Doe',
+            email: 'john@example.com',
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects invalid email', () => {
+        const result = customerInfoSchema.safeParse({
+            firstName: 'John',
+            lastName: 'Doe',
+            email: 'invalid',
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('checkoutSchema', () => {
+    const validCheckout = {
+        eventId: 1,
+        items: [{ ticketTypeId: 1, quantity: 2 }],
+        customer: {
+            firstName: 'John',
+            lastName: 'Doe',
+            email: 'john@example.com',
+        },
+        acceptTerms: true,
+    };
+    it('accepts valid checkout data', () => {
+        const result = checkoutSchema.safeParse(validCheckout);
+        expect(result.success).toBe(true);
+    });
+    it('accepts checkout with promo code', () => {
+        const result = checkoutSchema.safeParse({
+            ...validCheckout,
+            promoCode: 'SAVE10',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts checkout with billing address', () => {
+        const result = checkoutSchema.safeParse({
+            ...validCheckout,
+            billingAddress: {
+                street: '123 Main St',
+                city: 'San Francisco',
+                state: 'CA',
+                zipCode: '94102',
+            },
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects empty cart', () => {
+        const result = checkoutSchema.safeParse({
+            ...validCheckout,
+            items: [],
+        });
+        expect(result.success).toBe(false);
+        if (!result.success) {
+            const error = result.error.issues.find(e => e.path.includes('items'));
+            expect(error?.message).toBe('Cart must have at least one item');
+        }
+    });
+    it('rejects if terms not accepted', () => {
+        const result = checkoutSchema.safeParse({
+            ...validCheckout,
+            acceptTerms: false,
+        });
+        expect(result.success).toBe(false);
+        if (!result.success) {
+            const error = result.error.issues.find(e => e.path.includes('acceptTerms'));
+            expect(error?.message).toBe('You must accept the terms and conditions');
+        }
+    });
+    it('rejects invalid event ID', () => {
+        const result = checkoutSchema.safeParse({
+            ...validCheckout,
+            eventId: -1,
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('boxOfficeCheckoutSchema', () => {
+    const validBoxOffice = {
+        eventId: 1,
+        items: [{ ticketTypeId: 1, quantity: 2 }],
+        customer: {},
+        paymentMethod: 'cash',
+    };
+    it('accepts valid box office checkout', () => {
+        const result = boxOfficeCheckoutSchema.safeParse(validBoxOffice);
+        expect(result.success).toBe(true);
+    });
+    it('accepts box office with partial customer', () => {
+        const result = boxOfficeCheckoutSchema.safeParse({
+            ...validBoxOffice,
+            customer: {
+                firstName: 'John',
+            },
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts box office with full customer and notes', () => {
+        const result = boxOfficeCheckoutSchema.safeParse({
+            ...validBoxOffice,
+            customer: {
+                firstName: 'John',
+                lastName: 'Doe',
+                email: 'john@example.com',
+            },
+            notes: 'VIP customer',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts credit card payment', () => {
+        const result = boxOfficeCheckoutSchema.safeParse({
+            ...validBoxOffice,
+            paymentMethod: 'credit_card',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects invalid payment method', () => {
+        const result = boxOfficeCheckoutSchema.safeParse({
+            ...validBoxOffice,
+            paymentMethod: 'invalid',
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects empty cart', () => {
+        const result = boxOfficeCheckoutSchema.safeParse({
+            ...validBoxOffice,
+            items: [],
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('refundRequestSchema', () => {
+    const validRefund = {
+        orderId: '550e8400-e29b-41d4-a716-446655440000',
+        ticketIds: ['550e8400-e29b-41d4-a716-446655440001'],
+        reason: 'Customer requested refund',
+    };
+    it('accepts valid refund request', () => {
+        const result = refundRequestSchema.safeParse(validRefund);
+        expect(result.success).toBe(true);
+    });
+    it('accepts partial refund with amount', () => {
+        const result = refundRequestSchema.safeParse({
+            ...validRefund,
+            refundAmount: 25.5,
+            isPartial: true,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('defaults isPartial to false', () => {
+        const result = refundRequestSchema.safeParse(validRefund);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.isPartial).toBe(false);
+        }
+    });
+    it('rejects empty ticketIds', () => {
+        const result = refundRequestSchema.safeParse({
+            ...validRefund,
+            ticketIds: [],
+        });
+        expect(result.success).toBe(false);
+        if (!result.success) {
+            const error = result.error.issues.find(e => e.path.includes('ticketIds'));
+            expect(error?.message).toBe('At least one ticket must be selected');
+        }
+    });
+    it('rejects empty reason', () => {
+        const result = refundRequestSchema.safeParse({
+            ...validRefund,
+            reason: '',
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects invalid order UUID', () => {
+        const result = refundRequestSchema.safeParse({
+            ...validRefund,
+            orderId: 'not-a-uuid',
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('orderNoteSchema', () => {
+    it('accepts valid order note', () => {
+        const result = orderNoteSchema.safeParse({
+            orderId: '550e8400-e29b-41d4-a716-446655440000',
+            content: 'Customer called about their order',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('defaults isInternal to true', () => {
+        const result = orderNoteSchema.safeParse({
+            orderId: '550e8400-e29b-41d4-a716-446655440000',
+            content: 'Internal note',
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.isInternal).toBe(true);
+        }
+    });
+    it('accepts external note', () => {
+        const result = orderNoteSchema.safeParse({
+            orderId: '550e8400-e29b-41d4-a716-446655440000',
+            content: 'Thank you for your order!',
+            isInternal: false,
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.isInternal).toBe(false);
+        }
+    });
+    it('rejects empty content', () => {
+        const result = orderNoteSchema.safeParse({
+            orderId: '550e8400-e29b-41d4-a716-446655440000',
+            content: '',
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('orderFilterSchema', () => {
+    it('accepts empty filter', () => {
+        const result = orderFilterSchema.safeParse({});
+        expect(result.success).toBe(true);
+    });
+    it('accepts filter with status', () => {
+        const result = orderFilterSchema.safeParse({
+            status: 'completed',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts filter with date range', () => {
+        const result = orderFilterSchema.safeParse({
+            startDate: new Date('2025-01-01'),
+            endDate: new Date('2025-12-31'),
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts filter with pagination', () => {
+        const result = orderFilterSchema.safeParse({
+            limit: 10,
+            offset: 20,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts filter with search', () => {
+        const result = orderFilterSchema.safeParse({
+            search: 'john@example.com',
+            eventId: 123,
+            venueId: 456,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects invalid status', () => {
+        const result = orderFilterSchema.safeParse({
+            status: 'invalid',
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects negative offset', () => {
+        const result = orderFilterSchema.safeParse({
+            offset: -1,
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('orderResendSchema', () => {
+    it('accepts valid resend request', () => {
+        const result = orderResendSchema.safeParse({
+            orderId: '550e8400-e29b-41d4-a716-446655440000',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts resend with custom email', () => {
+        const result = orderResendSchema.safeParse({
+            orderId: '550e8400-e29b-41d4-a716-446655440000',
+            email: 'different@example.com',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects invalid order UUID', () => {
+        const result = orderResendSchema.safeParse({
+            orderId: 'not-a-uuid',
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects invalid email', () => {
+        const result = orderResendSchema.safeParse({
+            orderId: '550e8400-e29b-41d4-a716-446655440000',
+            email: 'invalid-email',
+        });
+        expect(result.success).toBe(false);
+    });
+});

package/dist/schemas/__tests__/user.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=user.test.d.ts.map

package/dist/schemas/__tests__/user.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user.test.d.ts","sourceRoot":"","sources":["../../../src/lib/schemas/__tests__/user.test.ts"],"names":[],"mappings":""}

package/dist/schemas/__tests__/user.test.js

@@ -0,0 +1,325 @@
+import { describe, expect, it } from 'vitest';
+import { teamInviteSchema, teamMemberSchema, teamMemberUpdateSchema, userFilterSchema, userPreferencesSchema, userProfileSchema, userProfileUpdateSchema, userRoleSchema, } from '../user';
+describe('userRoleSchema', () => {
+    it('accepts valid roles', () => {
+        const roles = ['owner', 'admin', 'manager', 'staff', 'viewer'];
+        roles.forEach(role => {
+            const result = userRoleSchema.safeParse(role);
+            expect(result.success).toBe(true);
+        });
+    });
+    it('rejects invalid role', () => {
+        const result = userRoleSchema.safeParse('superadmin');
+        expect(result.success).toBe(false);
+    });
+});
+describe('userProfileSchema', () => {
+    const validProfile = {
+        firstName: 'John',
+        lastName: 'Doe',
+        email: 'john@example.com',
+    };
+    it('accepts valid profile', () => {
+        const result = userProfileSchema.safeParse(validProfile);
+        expect(result.success).toBe(true);
+    });
+    it('accepts profile with phone', () => {
+        const result = userProfileSchema.safeParse({
+            ...validProfile,
+            phone: '555-123-4567',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts profile with bio', () => {
+        const result = userProfileSchema.safeParse({
+            ...validProfile,
+            bio: 'A comedy venue owner from San Francisco',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects missing first name', () => {
+        const { firstName, ...profileWithoutFirst } = validProfile;
+        const result = userProfileSchema.safeParse(profileWithoutFirst);
+        expect(result.success).toBe(false);
+    });
+    it('rejects missing last name', () => {
+        const { lastName, ...profileWithoutLast } = validProfile;
+        const result = userProfileSchema.safeParse(profileWithoutLast);
+        expect(result.success).toBe(false);
+    });
+    it('rejects invalid email', () => {
+        const result = userProfileSchema.safeParse({
+            ...validProfile,
+            email: 'invalid-email',
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects bio over 500 characters', () => {
+        const result = userProfileSchema.safeParse({
+            ...validProfile,
+            bio: 'x'.repeat(501),
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('userProfileUpdateSchema', () => {
+    it('accepts empty update (all fields optional)', () => {
+        const result = userProfileUpdateSchema.safeParse({});
+        expect(result.success).toBe(true);
+    });
+    it('accepts partial update', () => {
+        const result = userProfileUpdateSchema.safeParse({
+            firstName: 'Jane',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts full update', () => {
+        const result = userProfileUpdateSchema.safeParse({
+            firstName: 'Jane',
+            lastName: 'Smith',
+            email: 'jane@example.com',
+            phone: '555-987-6543',
+            bio: 'Updated bio',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects invalid email even when optional', () => {
+        const result = userProfileUpdateSchema.safeParse({
+            email: 'invalid-email',
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('userPreferencesSchema', () => {
+    it('accepts empty preferences (uses defaults)', () => {
+        const result = userPreferencesSchema.safeParse({});
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.emailNotifications).toBe(true);
+            expect(result.data.smsNotifications).toBe(false);
+            expect(result.data.marketingEmails).toBe(false);
+            expect(result.data.language).toBe('en');
+        }
+    });
+    it('accepts custom preferences', () => {
+        const result = userPreferencesSchema.safeParse({
+            emailNotifications: false,
+            smsNotifications: true,
+            marketingEmails: true,
+            timezone: 'America/Los_Angeles',
+            language: 'es',
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.emailNotifications).toBe(false);
+            expect(result.data.smsNotifications).toBe(true);
+            expect(result.data.marketingEmails).toBe(true);
+            expect(result.data.timezone).toBe('America/Los_Angeles');
+            expect(result.data.language).toBe('es');
+        }
+    });
+    it('accepts partial preferences', () => {
+        const result = userPreferencesSchema.safeParse({
+            smsNotifications: true,
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.smsNotifications).toBe(true);
+            expect(result.data.emailNotifications).toBe(true);
+        }
+    });
+});
+describe('teamMemberSchema', () => {
+    const validMember = {
+        email: 'team@example.com',
+        firstName: 'Team',
+        lastName: 'Member',
+        role: 'staff',
+    };
+    it('accepts valid team member', () => {
+        const result = teamMemberSchema.safeParse(validMember);
+        expect(result.success).toBe(true);
+    });
+    it('accepts team member with venue IDs', () => {
+        const result = teamMemberSchema.safeParse({
+            ...validMember,
+            venueIds: [1, 2, 3],
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts all roles', () => {
+        const roles = ['owner', 'admin', 'manager', 'staff', 'viewer'];
+        roles.forEach(role => {
+            const result = teamMemberSchema.safeParse({
+                ...validMember,
+                role,
+            });
+            expect(result.success).toBe(true);
+        });
+    });
+    it('rejects missing email', () => {
+        const { email, ...memberWithoutEmail } = validMember;
+        const result = teamMemberSchema.safeParse(memberWithoutEmail);
+        expect(result.success).toBe(false);
+    });
+    it('rejects invalid role', () => {
+        const result = teamMemberSchema.safeParse({
+            ...validMember,
+            role: 'invalid',
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects invalid venue ID', () => {
+        const result = teamMemberSchema.safeParse({
+            ...validMember,
+            venueIds: [-1, 0],
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('teamMemberUpdateSchema', () => {
+    it('accepts empty update', () => {
+        const result = teamMemberUpdateSchema.safeParse({});
+        expect(result.success).toBe(true);
+    });
+    it('accepts partial update with role', () => {
+        const result = teamMemberUpdateSchema.safeParse({
+            role: 'manager',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts partial update with venue IDs', () => {
+        const result = teamMemberUpdateSchema.safeParse({
+            venueIds: [4, 5, 6],
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects invalid role', () => {
+        const result = teamMemberUpdateSchema.safeParse({
+            role: 'invalid',
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('teamInviteSchema', () => {
+    const validInvite = {
+        email: 'newmember@example.com',
+        role: 'staff',
+        venueIds: [1],
+    };
+    it('accepts valid invite', () => {
+        const result = teamInviteSchema.safeParse(validInvite);
+        expect(result.success).toBe(true);
+    });
+    it('accepts invite with message', () => {
+        const result = teamInviteSchema.safeParse({
+            ...validInvite,
+            message: 'Welcome to the team!',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts invite with multiple venues', () => {
+        const result = teamInviteSchema.safeParse({
+            ...validInvite,
+            venueIds: [1, 2, 3, 4, 5],
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects empty venueIds', () => {
+        const result = teamInviteSchema.safeParse({
+            ...validInvite,
+            venueIds: [],
+        });
+        expect(result.success).toBe(false);
+        if (!result.success) {
+            const error = result.error.issues.find(e => e.path.includes('venueIds'));
+            expect(error?.message).toBe('At least one venue must be selected');
+        }
+    });
+    it('rejects missing email', () => {
+        const { email, ...inviteWithoutEmail } = validInvite;
+        const result = teamInviteSchema.safeParse(inviteWithoutEmail);
+        expect(result.success).toBe(false);
+    });
+    it('rejects invalid email', () => {
+        const result = teamInviteSchema.safeParse({
+            ...validInvite,
+            email: 'invalid',
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects message over 500 characters', () => {
+        const result = teamInviteSchema.safeParse({
+            ...validInvite,
+            message: 'x'.repeat(501),
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('userFilterSchema', () => {
+    it('accepts empty filter', () => {
+        const result = userFilterSchema.safeParse({});
+        expect(result.success).toBe(true);
+    });
+    it('accepts filter with role', () => {
+        const result = userFilterSchema.safeParse({
+            role: 'admin',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts filter with search', () => {
+        const result = userFilterSchema.safeParse({
+            search: 'john',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts filter with pagination', () => {
+        const result = userFilterSchema.safeParse({
+            limit: 25,
+            offset: 50,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts filter with venue and active status', () => {
+        const result = userFilterSchema.safeParse({
+            venueId: 123,
+            isActive: true,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts filter with all options', () => {
+        const result = userFilterSchema.safeParse({
+            search: 'manager',
+            role: 'manager',
+            venueId: 1,
+            isActive: true,
+            limit: 10,
+            offset: 0,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects invalid role in filter', () => {
+        const result = userFilterSchema.safeParse({
+            role: 'invalid',
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects negative limit', () => {
+        const result = userFilterSchema.safeParse({
+            limit: -1,
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects negative offset', () => {
+        const result = userFilterSchema.safeParse({
+            offset: -1,
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects zero limit', () => {
+        const result = userFilterSchema.safeParse({
+            limit: 0,
+        });
+        expect(result.success).toBe(false);
+    });
+});