@getmicdrop/svelte-components 5.17.1 → 5.17.4

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

@@ -0,0 +1,293 @@
+import { describe, expect, it } from 'vitest';
+import { eventFilterSchema, eventSchema } from '../event';
+import { performerBasicInfoSchema, performerSchema } from '../performer';
+import { promoCodeSchema } from '../promo';
+import { cartItemSchema, ticketSectionSchema, ticketTypeSchema, } from '../ticket';
+import { stageSchema, venueSchema } from '../venue';
+describe('eventSchema', () => {
+    const validEvent = {
+        title: 'Comedy Night',
+        startDateTime: new Date('2025-06-01T20:00:00'),
+        endDateTime: new Date('2025-06-01T22:00:00'),
+        timezone: 'America/Los_Angeles',
+        venueId: '550e8400-e29b-41d4-a716-446655440000',
+    };
+    it('accepts valid event', () => {
+        const result = eventSchema.safeParse(validEvent);
+        expect(result.success).toBe(true);
+    });
+    it('rejects end date before start date', () => {
+        const result = eventSchema.safeParse({
+            ...validEvent,
+            startDateTime: new Date('2025-06-01T22:00:00'),
+            endDateTime: new Date('2025-06-01T20:00:00'),
+        });
+        expect(result.success).toBe(false);
+        if (!result.success) {
+            const error = result.error.issues.find(e => e.path.includes('endDateTime'));
+            expect(error).toBeDefined();
+        }
+    });
+    it('defaults status to draft', () => {
+        const result = eventSchema.safeParse(validEvent);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.status).toBe('draft');
+        }
+    });
+    it('rejects invalid timezone', () => {
+        const result = eventSchema.safeParse({
+            ...validEvent,
+            timezone: 'Invalid/Timezone',
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('eventFilterSchema', () => {
+    it('accepts empty filter', () => {
+        const result = eventFilterSchema.safeParse({});
+        expect(result.success).toBe(true);
+    });
+    it('accepts filter with search', () => {
+        const result = eventFilterSchema.safeParse({
+            search: 'comedy',
+            status: 'published',
+        });
+        expect(result.success).toBe(true);
+    });
+});
+describe('ticketTypeSchema', () => {
+    const validTicket = {
+        name: 'General Admission',
+        ticketType: 'paid',
+        price: 25,
+        quantity: 100,
+        minimumTickets: 1,
+        maximumTickets: 10,
+    };
+    it('accepts valid ticket', () => {
+        const result = ticketTypeSchema.safeParse(validTicket);
+        expect(result.success).toBe(true);
+    });
+    it('rejects min exceeding max', () => {
+        const result = ticketTypeSchema.safeParse({
+            ...validTicket,
+            minimumTickets: 10,
+            maximumTickets: 5,
+        });
+        expect(result.success).toBe(false);
+        if (!result.success) {
+            const error = result.error.issues.find(e => e.path.includes('minimumTickets'));
+            expect(error?.message).toBe('Minimum cannot exceed maximum');
+        }
+    });
+    it('rejects sales end before start', () => {
+        const result = ticketTypeSchema.safeParse({
+            ...validTicket,
+            salesStartDateTime: new Date('2025-06-01'),
+            salesEndDateTime: new Date('2025-05-01'),
+        });
+        expect(result.success).toBe(false);
+    });
+    it('defaults visibility to visible', () => {
+        const result = ticketTypeSchema.safeParse(validTicket);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.visibility).toBe('visible');
+        }
+    });
+});
+describe('ticketSectionSchema', () => {
+    it('accepts valid section', () => {
+        const result = ticketSectionSchema.safeParse({
+            name: 'VIP Section',
+            capacity: 50,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects zero capacity', () => {
+        const result = ticketSectionSchema.safeParse({
+            name: 'VIP Section',
+            capacity: 0,
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('cartItemSchema', () => {
+    it('accepts valid cart item with UUID', () => {
+        const result = cartItemSchema.safeParse({
+            ticketTypeId: '550e8400-e29b-41d4-a716-446655440000',
+            quantity: 2,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts valid cart item with number ID', () => {
+        const result = cartItemSchema.safeParse({
+            ticketTypeId: 123,
+            quantity: 2,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects quantity over max', () => {
+        const result = cartItemSchema.safeParse({
+            ticketTypeId: 123,
+            quantity: 100,
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('venueSchema', () => {
+    const validVenue = {
+        name: 'The Comedy Club',
+        address: {
+            street: '123 Main St',
+            city: 'San Francisco',
+            state: 'CA',
+            zipCode: '94102',
+        },
+        timezone: 'America/Los_Angeles',
+    };
+    it('accepts valid venue', () => {
+        const result = venueSchema.safeParse(validVenue);
+        expect(result.success).toBe(true);
+    });
+    it('rejects missing name', () => {
+        const { name, ...venueWithoutName } = validVenue;
+        const result = venueSchema.safeParse(venueWithoutName);
+        expect(result.success).toBe(false);
+    });
+    it('defaults isActive to true', () => {
+        const result = venueSchema.safeParse(validVenue);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.isActive).toBe(true);
+        }
+    });
+});
+describe('stageSchema', () => {
+    it('accepts valid stage', () => {
+        const result = stageSchema.safeParse({
+            name: 'Main Stage',
+            capacity: 200,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts stage without capacity', () => {
+        const result = stageSchema.safeParse({
+            name: 'Main Stage',
+        });
+        expect(result.success).toBe(true);
+    });
+});
+describe('performerBasicInfoSchema', () => {
+    it('accepts valid performer info', () => {
+        const result = performerBasicInfoSchema.safeParse({
+            firstName: 'John',
+            lastName: 'Comedian',
+            email: 'john@example.com',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects invalid email', () => {
+        const result = performerBasicInfoSchema.safeParse({
+            firstName: 'John',
+            lastName: 'Comedian',
+            email: 'invalid-email',
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('performerSchema', () => {
+    it('accepts full performer data', () => {
+        const result = performerSchema.safeParse({
+            firstName: 'John',
+            lastName: 'Comedian',
+            email: 'john@example.com',
+            bio: 'A funny person',
+            tier: 3,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects tier over max', () => {
+        const result = performerSchema.safeParse({
+            firstName: 'John',
+            lastName: 'Comedian',
+            email: 'john@example.com',
+            tier: 10,
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('promoCodeSchema', () => {
+    it('accepts valid percent discount promo', () => {
+        const result = promoCodeSchema.safeParse({
+            code: 'SUMMER20',
+            discountType: 'percent',
+            percentAmount: 20,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts valid dollar discount promo', () => {
+        const result = promoCodeSchema.safeParse({
+            code: 'SAVE10',
+            discountType: 'dollar',
+            dollarAmount: 10,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects both discount types', () => {
+        const result = promoCodeSchema.safeParse({
+            code: 'INVALID',
+            discountType: 'percent',
+            percentAmount: 20,
+            dollarAmount: 10,
+        });
+        expect(result.success).toBe(false);
+    });
+    it('allows promo without discount if reveals hidden tickets', () => {
+        const result = promoCodeSchema.safeParse({
+            code: 'REVEAL',
+            discountType: 'percent',
+            revealHiddenTickets: true,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('requires usage limit when limited', () => {
+        const result = promoCodeSchema.safeParse({
+            code: 'LIMITED',
+            discountType: 'percent',
+            percentAmount: 20,
+            limitType: 'limited',
+        });
+        expect(result.success).toBe(false);
+    });
+    it('accepts limited promo with usage limit', () => {
+        const result = promoCodeSchema.safeParse({
+            code: 'LIMITED100',
+            discountType: 'percent',
+            percentAmount: 20,
+            limitType: 'limited',
+            usageLimit: 100,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('uppercases promo code', () => {
+        const result = promoCodeSchema.safeParse({
+            code: 'summer20',
+            discountType: 'percent',
+            percentAmount: 20,
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.code).toBe('SUMMER20');
+        }
+    });
+    it('rejects invalid promo code format', () => {
+        const result = promoCodeSchema.safeParse({
+            code: 'invalid code!',
+            discountType: 'percent',
+            percentAmount: 20,
+        });
+        expect(result.success).toBe(false);
+    });
+});

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

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

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

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

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":""}