@axova/shared 1.0.0

package/src/types/events.ts

@@ -0,0 +1,646 @@
+import { z } from "zod";
+
+// Base event schema
+export const BaseEventSchema = z.object({
+	id: z.string(),
+	timestamp: z.string(),
+	source: z.string(),
+	version: z.string().default("1.0"),
+});
+
+// Store Events
+export const StoreCreatedEventSchema = BaseEventSchema.extend({
+	type: z.literal("store.created"),
+	data: z.object({
+		storeId: z.string(),
+		userId: z.string(),
+		storeName: z.string(),
+		subdomain: z.string(),
+		timezone: z.string(),
+		currency: z.string(),
+		isActive: z.boolean(),
+		organizationId: z.string().optional(),
+	}),
+});
+
+export const StoreUpdatedEventSchema = BaseEventSchema.extend({
+	type: z.literal("store.updated"),
+	data: z.object({
+		storeId: z.string(),
+		userId: z.string(),
+		changes: z.record(z.unknown()),
+		previousValues: z.record(z.unknown()).optional(),
+	}),
+});
+
+// Compliance Events
+export const ComplianceViolationDetectedEventSchema = BaseEventSchema.extend({
+	type: z.literal("compliance.violation.detected"),
+	data: z.object({
+		storeId: z.string(),
+		violationType: z.enum([
+			"CONTENT_VIOLATION",
+			"POLICY_VIOLATION",
+			"BEHAVIOR_VIOLATION",
+		]),
+		severity: z.enum(["LOW", "MEDIUM", "HIGH", "CRITICAL"]),
+		description: z.string(),
+		evidence: z.record(z.unknown()).optional(),
+		autoAction: z.enum(["NONE", "WARNING", "SUSPEND", "BAN"]).optional(),
+	}),
+});
+
+export const StoreSuspendedEventSchema = BaseEventSchema.extend({
+	type: z.literal("store.suspended"),
+	data: z.object({
+		storeId: z.string(),
+		reason: z.string(),
+		duration: z.number().optional(), // Duration in hours, null for indefinite
+		suspendedBy: z.string(),
+		additionalNotes: z.string().optional(),
+	}),
+});
+
+export const StoreUnbannedEventSchema = BaseEventSchema.extend({
+	type: z.literal("store.unbanned"),
+	data: z.object({
+		storeId: z.string(),
+		reason: z.string(),
+		unbannedBy: z.string(),
+		previousBanReason: z.string().optional(),
+		additionalNotes: z.string().optional(),
+	}),
+});
+
+// Notification Events
+export const NotificationSendEventSchema = BaseEventSchema.extend({
+	type: z.literal("notification.send"),
+	data: z.object({
+		recipientId: z.string(),
+		recipientType: z.enum(["USER", "STORE", "ADMIN"]),
+		channel: z.enum(["EMAIL", "SMS", "IN_APP", "PUSH"]),
+		template: z.string(),
+		templateData: z.record(z.unknown()),
+		priority: z.enum(["LOW", "NORMAL", "HIGH", "URGENT"]).default("NORMAL"),
+		scheduledFor: z.string().optional(), // ISO date string
+	}),
+});
+
+// Audit Events
+export const AuditLoggedEventSchema = BaseEventSchema.extend({
+	type: z.literal("audit.logged"),
+	data: z.object({
+		action: z.string(),
+		resource: z.string(),
+		resourceId: z.string(),
+		performedBy: z.string(),
+		performedByType: z.enum(["USER", "SYSTEM", "ADMIN", "SERVICE"]),
+		changes: z.record(z.unknown()).optional(),
+		metadata: z.record(z.unknown()).optional(),
+		ip: z.string().optional(),
+		userAgent: z.string().optional(),
+	}),
+});
+
+// Appeal Events
+export const AppealSubmittedEventSchema = BaseEventSchema.extend({
+	type: z.literal("appeal.submitted"),
+	data: z.object({
+		appealId: z.string(),
+		storeId: z.string(),
+		userId: z.string(),
+		appealType: z.enum([
+			"BAN_APPEAL",
+			"SUSPENSION_APPEAL",
+			"WARNING_APPEAL",
+			"POLICY_DISPUTE",
+		]),
+		reason: z.string(),
+		evidence: z.array(z.string()).optional(), // Array of URLs or file references
+		originalViolationId: z.string().optional(),
+	}),
+});
+
+export const AppealReviewedEventSchema = BaseEventSchema.extend({
+	type: z.literal("appeal.reviewed"),
+	data: z.object({
+		appealId: z.string(),
+		storeId: z.string(),
+		reviewedBy: z.string(),
+		decision: z.enum(["APPROVED", "REJECTED", "PARTIALLY_APPROVED"]),
+		reasoning: z.string(),
+		actionTaken: z.string().optional(),
+		reviewNotes: z.string().optional(),
+	}),
+});
+
+// Type exports
+export type StoreCreatedEvent = z.infer<typeof StoreCreatedEventSchema>;
+export type StoreUpdatedEvent = z.infer<typeof StoreUpdatedEventSchema>;
+export type ComplianceViolationDetectedEvent = z.infer<
+	typeof ComplianceViolationDetectedEventSchema
+>;
+export type StoreSuspendedEvent = z.infer<typeof StoreSuspendedEventSchema>;
+export type StoreUnbannedEvent = z.infer<typeof StoreUnbannedEventSchema>;
+export type NotificationSendEvent = z.infer<typeof NotificationSendEventSchema>;
+export type AuditLoggedEvent = z.infer<typeof AuditLoggedEventSchema>;
+export type AppealSubmittedEvent = z.infer<typeof AppealSubmittedEventSchema>;
+export type AppealReviewedEvent = z.infer<typeof AppealReviewedEventSchema>;
+
+// Union type of all events
+// Customer Events
+export const CustomerCreatedEventSchema = BaseEventSchema.extend({
+	type: z.literal("customer.created"),
+	data: z.object({
+		customerId: z.string(),
+		userId: z.string(),
+		email: z.string(),
+		firstName: z.string(),
+		lastName: z.string(),
+		customerType: z.string(),
+		registrationSource: z.string(),
+		storeLocationId: z.string().optional(),
+	}),
+});
+
+export const CustomerUpdatedEventSchema = BaseEventSchema.extend({
+	type: z.literal("customer.updated"),
+	data: z.object({
+		customerId: z.string(),
+		userId: z.string(),
+		changes: z.record(z.unknown()),
+		previousValues: z.record(z.unknown()),
+		registrationSourceChanged: z.boolean(),
+	}),
+});
+
+export const CustomerDeletedEventSchema = BaseEventSchema.extend({
+	type: z.literal("customer.deleted"),
+	data: z.object({
+		customerId: z.string(),
+		userId: z.string(),
+		email: z.string(),
+		customerType: z.string(),
+		registrationSource: z.string(),
+		totalSpent: z.string(),
+		totalOrders: z.number(),
+		totalVisits: z.number(),
+		totalInteractions: z.number(),
+	}),
+});
+
+export const CustomerVisitCreatedEventSchema = BaseEventSchema.extend({
+	type: z.literal("customer.visit.created"),
+	data: z.object({
+		visitId: z.string(),
+		customerId: z.string(),
+		visitType: z.string(),
+		storeLocationId: z.string().optional(),
+		outcome: z.string().optional(),
+		duration: z.number().optional(),
+	}),
+});
+
+export const CustomerInteractionCreatedEventSchema = BaseEventSchema.extend({
+	type: z.literal("customer.interaction.created"),
+	data: z.object({
+		interactionId: z.string(),
+		customerId: z.string(),
+		interactionType: z.string(),
+		targetType: z.string().optional(),
+		targetId: z.string().optional(),
+		outcome: z.string().optional(),
+		staffId: z.string().optional(),
+	}),
+});
+
+export const CustomerNoteCreatedEventSchema = BaseEventSchema.extend({
+	type: z.literal("customer.note.created"),
+	data: z.object({
+		noteId: z.string(),
+		customerId: z.string(),
+		noteType: z.string(),
+		priority: z.string(),
+		isAlert: z.boolean(),
+		createdBy: z.string(),
+	}),
+});
+
+export const CustomerSupportTicketCreatedEventSchema = BaseEventSchema.extend({
+	type: z.literal("customer.support.ticket.created"),
+	data: z.object({
+		ticketId: z.string(),
+		ticketNumber: z.string(),
+		customerId: z.string(),
+		subject: z.string(),
+		category: z.string(),
+		priority: z.string(),
+	}),
+});
+
+export const CustomerReviewSubmittedEventSchema = BaseEventSchema.extend({
+	type: z.literal("customer.review.submitted"),
+	data: z.object({
+		reviewId: z.string(),
+		customerId: z.string(),
+		targetType: z.string(),
+		targetId: z.string(),
+		rating: z.number(),
+		isVerifiedPurchase: z.boolean(),
+	}),
+});
+
+// Order Events
+export const OrderCreatedEventSchema = BaseEventSchema.extend({
+	type: z.literal("order.created"),
+	data: z.object({
+		orderId: z.string(),
+		orderNumber: z.string(),
+		storeId: z.string(),
+		customerId: z.string().optional(),
+		userId: z.string().optional(),
+		orderType: z.string(),
+		orderSource: z.string(),
+		status: z.string(),
+		totalAmount: z.string(),
+		currency: z.string(),
+		itemCount: z.number(),
+		isGuestOrder: z.boolean(),
+		paymentMethod: z.string().optional(),
+		shippingRequired: z.boolean(),
+		priority: z.string(),
+	}),
+});
+
+export const OrderUpdatedEventSchema = BaseEventSchema.extend({
+	type: z.literal("order.updated"),
+	data: z.object({
+		orderId: z.string(),
+		orderNumber: z.string(),
+		storeId: z.string(),
+		customerId: z.string().optional(),
+		changes: z.record(z.unknown()),
+		previousValues: z.record(z.unknown()),
+		statusChanged: z.boolean(),
+		paymentStatusChanged: z.boolean(),
+		fulfillmentStatusChanged: z.boolean(),
+		amountChanged: z.boolean(),
+	}),
+});
+
+export const OrderStatusChangedEventSchema = BaseEventSchema.extend({
+	type: z.literal("order.status.changed"),
+	data: z.object({
+		orderId: z.string(),
+		orderNumber: z.string(),
+		storeId: z.string(),
+		customerId: z.string().optional(),
+		fromStatus: z.string(),
+		toStatus: z.string(),
+		reason: z.string().optional(),
+		actorId: z.string(),
+		actorType: z.string(),
+		timestamp: z.string(),
+	}),
+});
+
+export const OrderPaymentProcessedEventSchema = BaseEventSchema.extend({
+	type: z.literal("order.payment.processed"),
+	data: z.object({
+		orderId: z.string(),
+		paymentId: z.string(),
+		transactionId: z.string().optional(),
+		paymentMethod: z.string(),
+		paymentProvider: z.string().optional(),
+		amount: z.string(),
+		currency: z.string(),
+		status: z.string(),
+		isSuccessful: z.boolean(),
+		failureReason: z.string().optional(),
+	}),
+});
+
+export const OrderShippedEventSchema = BaseEventSchema.extend({
+	type: z.literal("order.shipped"),
+	data: z.object({
+		orderId: z.string(),
+		fulfillmentId: z.string(),
+		trackingNumber: z.string().optional(),
+		trackingUrl: z.string().optional(),
+		shippingCarrier: z.string().optional(),
+		shippingService: z.string().optional(),
+		estimatedDeliveryDate: z.string().optional(),
+		packedBy: z.string().optional(),
+		shippedBy: z.string().optional(),
+	}),
+});
+
+export const OrderDeliveredEventSchema = BaseEventSchema.extend({
+	type: z.literal("order.delivered"),
+	data: z.object({
+		orderId: z.string(),
+		fulfillmentId: z.string(),
+		deliveredAt: z.string(),
+		deliveredBy: z.string().optional(),
+		signedBy: z.string().optional(),
+		deliveryLocation: z.string().optional(),
+		proofOfDelivery: z.record(z.unknown()).optional(),
+	}),
+});
+
+export const OrderCancelledEventSchema = BaseEventSchema.extend({
+	type: z.literal("order.cancelled"),
+	data: z.object({
+		orderId: z.string(),
+		orderNumber: z.string(),
+		storeId: z.string(),
+		customerId: z.string().optional(),
+		cancellationReason: z.string(),
+		cancelledBy: z.string(),
+		cancelledByType: z.string(),
+		refundRequired: z.boolean(),
+		refundAmount: z.string().optional(),
+		inventoryReleased: z.boolean(),
+	}),
+});
+
+export const OrderRefundedEventSchema = BaseEventSchema.extend({
+	type: z.literal("order.refunded"),
+	data: z.object({
+		orderId: z.string(),
+		paymentId: z.string(),
+		refundId: z.string(),
+		refundAmount: z.string(),
+		refundReason: z.string(),
+		refundMethod: z.string(),
+		isPartialRefund: z.boolean(),
+		processedBy: z.string(),
+		customerNotified: z.boolean(),
+	}),
+});
+
+export const OrderNoteAddedEventSchema = BaseEventSchema.extend({
+	type: z.literal("order.note.added"),
+	data: z.object({
+		orderId: z.string(),
+		noteId: z.string(),
+		noteType: z.string(),
+		content: z.string(),
+		isCustomerVisible: z.boolean(),
+		priority: z.string(),
+		createdBy: z.string(),
+		createdByName: z.string(),
+		requiresFollowUp: z.boolean(),
+	}),
+});
+
+export const OrderItemAddedEventSchema = BaseEventSchema.extend({
+	type: z.literal("order.item.added"),
+	data: z.object({
+		orderId: z.string(),
+		itemId: z.string(),
+		productId: z.string(),
+		variantId: z.string().optional(),
+		sku: z.string(),
+		productTitle: z.string(),
+		quantity: z.number(),
+		unitPrice: z.string(),
+		totalPrice: z.string(),
+		addedBy: z.string(),
+	}),
+});
+
+export const OrderItemRemovedEventSchema = BaseEventSchema.extend({
+	type: z.literal("order.item.removed"),
+	data: z.object({
+		orderId: z.string(),
+		itemId: z.string(),
+		productId: z.string(),
+		sku: z.string(),
+		productTitle: z.string(),
+		quantity: z.number(),
+		removedBy: z.string(),
+		removalReason: z.string().optional(),
+	}),
+});
+
+export const OrderDiscountAppliedEventSchema = BaseEventSchema.extend({
+	type: z.literal("order.discount.applied"),
+	data: z.object({
+		orderId: z.string(),
+		discountId: z.string(),
+		discountCode: z.string().optional(),
+		discountType: z.string(),
+		discountAmount: z.string(),
+		discountPercentage: z.number().optional(),
+		appliedBy: z.string().optional(),
+		campaignId: z.string().optional(),
+	}),
+});
+
+// Subscription Events
+export const SubscriptionOrderCreatedEventSchema = BaseEventSchema.extend({
+	type: z.literal("subscription.order.created"),
+	data: z.object({
+		subscriptionId: z.string(),
+		orderId: z.string(),
+		orderNumber: z.string(),
+		storeId: z.string(),
+		customerId: z.string().optional(),
+		frequency: z.string(),
+		planId: z.string(),
+		totalAmount: z.string(),
+		correlationId: z.string().optional(),
+	}),
+});
+
+export const SubscriptionRenewedEventSchema = BaseEventSchema.extend({
+	type: z.literal("subscription.renewed"),
+	data: z.object({
+		subscriptionId: z.string(),
+		orderId: z.string(),
+		orderNumber: z.string(),
+		storeId: z.string(),
+		customerId: z.string().optional(),
+		cycle: z.number(),
+		totalAmount: z.string(),
+		correlationId: z.string().optional(),
+	}),
+});
+
+export const SubscriptionCancelledEventSchema = BaseEventSchema.extend({
+	type: z.literal("subscription.cancelled"),
+	data: z.object({
+		subscriptionId: z.string(),
+		orderId: z.string(),
+		orderNumber: z.string(),
+		storeId: z.string(),
+		customerId: z.string().optional(),
+		reason: z.string().optional(),
+		action: z.string(),
+		parameters: z.record(z.unknown()).optional(),
+		correlationId: z.string().optional(),
+	}),
+});
+
+export const OrderReturnRequestedEventSchema = BaseEventSchema.extend({
+	type: z.literal("order.return.requested"),
+	data: z.object({
+		orderId: z.string(),
+		orderNumber: z.string(),
+		storeId: z.string(),
+		customerId: z.string(),
+		returnId: z.string(),
+		returnType: z.string(),
+		reason: z.string(),
+		itemCount: z.number(),
+		totalAmount: z.string().optional(),
+		correlationId: z.string().optional(),
+	}),
+});
+
+export const OrderRefundProcessedEventSchema = BaseEventSchema.extend({
+	type: z.literal("order.refund.processed"),
+	data: z.object({
+		orderId: z.string(),
+		orderNumber: z.string(),
+		storeId: z.string(),
+		customerId: z.string().optional(),
+		refundId: z.string(),
+		refundAmount: z.string(),
+		refundMethod: z.string(),
+		reason: z.string(),
+		processedBy: z.string(),
+		correlationId: z.string().optional(),
+	}),
+});
+
+// Order event types
+export type OrderCreatedEvent = z.infer<typeof OrderCreatedEventSchema>;
+export type OrderUpdatedEvent = z.infer<typeof OrderUpdatedEventSchema>;
+export type OrderStatusChangedEvent = z.infer<
+	typeof OrderStatusChangedEventSchema
+>;
+export type OrderPaymentProcessedEvent = z.infer<
+	typeof OrderPaymentProcessedEventSchema
+>;
+export type OrderShippedEvent = z.infer<typeof OrderShippedEventSchema>;
+export type OrderDeliveredEvent = z.infer<typeof OrderDeliveredEventSchema>;
+export type OrderCancelledEvent = z.infer<typeof OrderCancelledEventSchema>;
+export type OrderRefundedEvent = z.infer<typeof OrderRefundedEventSchema>;
+export type OrderNoteAddedEvent = z.infer<typeof OrderNoteAddedEventSchema>;
+export type OrderItemAddedEvent = z.infer<typeof OrderItemAddedEventSchema>;
+export type OrderItemRemovedEvent = z.infer<typeof OrderItemRemovedEventSchema>;
+export type OrderDiscountAppliedEvent = z.infer<
+	typeof OrderDiscountAppliedEventSchema
+>;
+
+// Subscription event types
+export type SubscriptionOrderCreatedEvent = z.infer<
+	typeof SubscriptionOrderCreatedEventSchema
+>;
+export type SubscriptionRenewedEvent = z.infer<
+	typeof SubscriptionRenewedEventSchema
+>;
+export type SubscriptionCancelledEvent = z.infer<
+	typeof SubscriptionCancelledEventSchema
+>;
+export type OrderReturnRequestedEvent = z.infer<
+	typeof OrderReturnRequestedEventSchema
+>;
+export type OrderRefundProcessedEvent = z.infer<
+	typeof OrderRefundProcessedEventSchema
+>;
+
+// Customer event types
+export type CustomerCreatedEvent = z.infer<typeof CustomerCreatedEventSchema>;
+export type CustomerUpdatedEvent = z.infer<typeof CustomerUpdatedEventSchema>;
+export type CustomerDeletedEvent = z.infer<typeof CustomerDeletedEventSchema>;
+export type CustomerVisitCreatedEvent = z.infer<
+	typeof CustomerVisitCreatedEventSchema
+>;
+export type CustomerInteractionCreatedEvent = z.infer<
+	typeof CustomerInteractionCreatedEventSchema
+>;
+export type CustomerNoteCreatedEvent = z.infer<
+	typeof CustomerNoteCreatedEventSchema
+>;
+export type CustomerSupportTicketCreatedEvent = z.infer<
+	typeof CustomerSupportTicketCreatedEventSchema
+>;
+export type CustomerReviewSubmittedEvent = z.infer<
+	typeof CustomerReviewSubmittedEventSchema
+>;
+
+export type AxovaEvent =
+	| StoreCreatedEvent
+	| StoreUpdatedEvent
+	| ComplianceViolationDetectedEvent
+	| StoreSuspendedEvent
+	| StoreUnbannedEvent
+	| NotificationSendEvent
+	| AuditLoggedEvent
+	| AppealSubmittedEvent
+	| AppealReviewedEvent
+	| OrderCreatedEvent
+	| OrderUpdatedEvent
+	| OrderStatusChangedEvent
+	| OrderPaymentProcessedEvent
+	| OrderShippedEvent
+	| OrderDeliveredEvent
+	| OrderCancelledEvent
+	| OrderRefundedEvent
+	| OrderNoteAddedEvent
+	| OrderItemAddedEvent
+	| OrderItemRemovedEvent
+	| OrderDiscountAppliedEvent
+	| SubscriptionOrderCreatedEvent
+	| SubscriptionRenewedEvent
+	| SubscriptionCancelledEvent
+	| OrderReturnRequestedEvent
+	| OrderRefundProcessedEvent
+	| CustomerCreatedEvent
+	| CustomerUpdatedEvent
+	| CustomerDeletedEvent
+	| CustomerVisitCreatedEvent
+	| CustomerInteractionCreatedEvent
+	| CustomerNoteCreatedEvent
+	| CustomerSupportTicketCreatedEvent
+	| CustomerReviewSubmittedEvent;
+
+// Kafka topic mappings
+export const KAFKA_TOPICS = {
+	STORE_CREATED: "store.created",
+	STORE_UPDATED: "store.updated",
+	COMPLIANCE_VIOLATION_DETECTED: "compliance.violation.detected",
+	STORE_SUSPENDED: "store.suspended",
+	STORE_UNBANNED: "store.unbanned",
+	NOTIFICATION_SEND: "notification.send",
+	AUDIT_LOGGED: "audit.logged",
+	APPEAL_SUBMITTED: "appeal.submitted",
+	APPEAL_REVIEWED: "appeal.reviewed",
+	// Order service topics
+	ORDER_CREATED: "order.created",
+	ORDER_UPDATED: "order.updated",
+	ORDER_STATUS_CHANGED: "order.status.changed",
+	ORDER_PAYMENT_PROCESSED: "order.payment.processed",
+	ORDER_SHIPPED: "order.shipped",
+	ORDER_DELIVERED: "order.delivered",
+	ORDER_CANCELLED: "order.cancelled",
+	ORDER_REFUNDED: "order.refunded",
+	ORDER_NOTE_ADDED: "order.note.added",
+	ORDER_ITEM_ADDED: "order.item.added",
+	ORDER_ITEM_REMOVED: "order.item.removed",
+	ORDER_DISCOUNT_APPLIED: "order.discount.applied",
+	// Customer service topics
+	CUSTOMER_CREATED: "customer.created",
+	CUSTOMER_UPDATED: "customer.updated",
+	CUSTOMER_DELETED: "customer.deleted",
+	CUSTOMER_VISIT_CREATED: "customer.visit.created",
+	CUSTOMER_INTERACTION_CREATED: "customer.interaction.created",
+	CUSTOMER_NOTE_CREATED: "customer.note.created",
+	CUSTOMER_SUPPORT_TICKET_CREATED: "customer.support.ticket.created",
+	CUSTOMER_REVIEW_SUBMITTED: "customer.review.submitted",
+} as const;
+
+export type KafkaTopic = (typeof KAFKA_TOPICS)[keyof typeof KAFKA_TOPICS];

package/src/utils/errorHandler.ts

@@ -0,0 +1,44 @@
+import type { FastifyReply } from "fastify";
+
+export class APIError extends Error {
+	statusCode: number;
+	details?: unknown;
+
+	constructor(message: string, statusCode = 400, details?: unknown) {
+		super(message);
+		this.statusCode = statusCode;
+		this.details = details;
+	}
+}
+
+/**
+ * Handles API errors in a unified way.
+ * @param {FastifyReply} reply The Fastify reply object.
+ * @param {APIError} error The API error object.
+ */
+export const handleAPIError = (
+	reply: FastifyReply,
+	error: APIError | Error,
+) => {
+	// Default status code
+	let statusCode = 500;
+	let details: unknown;
+
+	// If it's an APIError, use its status code and details
+	if (error instanceof APIError) {
+		statusCode = error.statusCode || 500;
+		details = error.details;
+	}
+
+	// Ensure there's always a message
+	const message = error.message || "An unexpected error occurred";
+
+	reply.status(statusCode).send({
+		success: false,
+		message,
+		...(details ? { details } : {}),
+	});
+
+	// Log the error for debugging
+	console.error(`[API Error] ${statusCode}: ${message}`, details || "");
+};

package/src/utils/subdomain.ts

@@ -0,0 +1,19 @@
+import { eq } from "drizzle-orm";
+import { db } from "../lib/db";
+import { stores } from "../schemas/store/store-schema";
+
+/**
+ * Checks if a subdomain is available.
+ * @param subdomain The subdomain to check.
+ * @returns {Promise<boolean>} True if available, false if taken.
+ */
+export const isSubdomainAvailable = async (
+	subdomain: string,
+): Promise<boolean> => {
+	const existingStore = await db
+		.select()
+		.from(stores)
+		.where(eq(stores.subdomain, subdomain))
+		.limit(1);
+	return existingStore.length === 0;
+};