@revenexx/cover 0.1.0 → 0.1.1

package/server/services/ApiCartService.ts

@@ -1,4 +1,5 @@
 import type { H3Event } from "h3";
+import type { Models } from "@revenexx/sdk";
 
 import type { CartItem } from "../../app/interfaces/cart-item";
 import type { StoredSession } from "../../app/interfaces/auth";
@@ -137,11 +138,15 @@ function toSummary(cart: ApiCart): CartSummaryRow {
  */
 export class ApiCartService implements ICartService, ICartManager {
 	private async listActive(owner: CartOwner): Promise<ApiCart[]> {
-		const { items } = await useRevenexxApi().get<{ items: ApiCart[] }>("/v1/carts", {
-			...ownerQuery(owner),
-			status: "active",
-			limit: 100,
-			order: "updated_at.desc",
+		// Raw call: carts.list does not declare its query parameters in the
+		// contract yet, so the generated cartsList() cannot filter by owner.
+		const { items } = await useRevenexxSdk().call<{ items: ApiCart[] }>("GET", "/v1/carts", {
+			query: {
+				...ownerQuery(owner),
+				status: "active",
+				limit: 100,
+				order: "updated_at.desc",
+			},
 		});
 		return items;
 	}
@@ -152,11 +157,11 @@ export class ApiCartService implements ICartService, ICartManager {
 		if (current) {
 			return current;
 		}
-		return useRevenexxApi().post<ApiCart>("/v1/carts", {
+		return await useRevenexxSdk().carts.cartsCreate({
 			name: DEFAULT_CART_NAME,
-			...(owner.contactId ? { contact_id: owner.contactId } : { session_key: owner.sessionKey }),
-			is_current: true,
-		});
+			...(owner.contactId ? { contactId: owner.contactId } : { sessionKey: owner.sessionKey }),
+			isCurrent: true,
+		}) as unknown as ApiCart;
 	}
 
 	// ---- ICartService (the active cart) --------------------------------
@@ -168,16 +173,16 @@ export class ApiCartService implements ICartService, ICartManager {
 		if (!current) {
 			return [];
 		}
-		const { items } = await useRevenexxApi().get<{ items: ApiCartLine[] }>(`/v1/carts/${current.id}/items`);
+		const { items } = await useRevenexxSdk().carts.cartsItemsList({ cartId: current.id }) as unknown as { items: ApiCartLine[] };
 		return items.map(toCartItem);
 	}
 
 	async saveItems(event: H3Event, items: CartItem[]): Promise<void> {
 		const owner = resolveOwner(event);
 		const cart = await this.ensureActiveCart(owner);
-		await useRevenexxApi().request(`/v1/carts/${cart.id}/items`, {
-			method: "PUT",
-			body: { items: items.map((item, index) => toApiLine(item, index)) },
+		await useRevenexxSdk().carts.cartsItemsReplace({
+			cartId: cart.id,
+			items: items.map((item, index) => toApiLine(item, index)) as unknown as Models.CartItemCreateRequest[],
 		});
 	}
 
@@ -199,30 +204,43 @@ export class ApiCartService implements ICartService, ICartManager {
 
 	async createCart(event: H3Event, name: string, activate: boolean): Promise<CartSummaryRow> {
 		const owner = resolveOwner(event);
-		const cart = await useRevenexxApi().post<ApiCart>("/v1/carts", {
+		const cart = await useRevenexxSdk().carts.cartsCreate({
 			name: name.trim() || DEFAULT_CART_NAME,
-			...(owner.contactId ? { contact_id: owner.contactId } : { session_key: owner.sessionKey }),
-			is_current: activate,
-		});
+			...(owner.contactId ? { contactId: owner.contactId } : { sessionKey: owner.sessionKey }),
+			isCurrent: activate,
+		}) as unknown as ApiCart;
 		return { ...toSummary(cart), active: activate };
 	}
 
 	async renameCart(event: H3Event, id: string, name: string): Promise<void> {
-		await useRevenexxApi().put(`/v1/carts/${id}`, { name: name.trim() });
+		await useRevenexxSdk().carts.cartsUpdate({ id, name: name.trim() });
 	}
 
 	async deleteCart(event: H3Event, id: string): Promise<void> {
-		await useRevenexxApi().request(`/v1/carts/${id}`, { method: "DELETE" });
+		await useRevenexxSdk().carts.cartsDelete({ id });
 	}
 
 	async activateCart(event: H3Event, id: string): Promise<CartItem[]> {
-		await useRevenexxApi().post(`/v1/carts/${id}/activate`, {});
-		const { items } = await useRevenexxApi().get<{ items: ApiCartLine[] }>(`/v1/carts/${id}/items`);
+		await useRevenexxSdk().carts.cartsActivate({ id });
+		const { items } = await useRevenexxSdk().carts.cartsItemsList({ cartId: id }) as unknown as { items: ApiCartLine[] };
 		return items.map(toCartItem);
 	}
 
 	async addItemToCart(event: H3Event, id: string, item: CartItem): Promise<void> {
-		await useRevenexxApi().post(`/v1/carts/${id}/items`, toApiLine(item, 0));
+		const line = toApiLine(item, 0);
+		await useRevenexxSdk().carts.cartsItemsCreate({
+			cartId: id,
+			...(line.product_id ? { productId: String(line.product_id) } : {}),
+			...(line.sku ? { sku: String(line.sku) } : {}),
+			name: String(line.name),
+			quantity: Number(line.quantity),
+			...(line.unit ? { unit: String(line.unit) } : {}),
+			unitPrice: Number(line.unit_price),
+			taxRate: Number(line.tax_rate),
+			position: Number(line.position),
+			snapshot: line.snapshot as object,
+			metadata: line.metadata as object,
+		});
 	}
 
 	async orderActiveCart(event: H3Event, orderRef: string): Promise<string | null> {
@@ -232,7 +250,7 @@ export class ApiCartService implements ICartService, ICartManager {
 		if (!current) {
 			return null;
 		}
-		await useRevenexxApi().post(`/v1/carts/${current.id}/order`, { order_ref: orderRef });
+		await useRevenexxSdk().carts.cartsOrder({ id: current.id, orderRef });
 		return current.id;
 	}
 
@@ -245,10 +263,10 @@ export class ApiCartService implements ICartService, ICartManager {
 		// the session cart is adopted as the customer's cart.
 		const customerCarts = await this.listActive({ contactId, sessionKey: "" });
 		const target = customerCarts.find(c => c.is_current) ?? customerCarts[0];
-		await useRevenexxApi().post("/v1/carts/claim", {
-			session_key: sessionKey,
-			contact_id: contactId,
-			...(target ? { target_cart_id: target.id } : {}),
+		await useRevenexxSdk().carts.cartsClaim({
+			sessionKey,
+			contactId,
+			...(target ? { targetCartId: target.id } : {}),
 		});
 	}
 }

package/server/services/ApiMarketService.ts

@@ -38,16 +38,14 @@ export class ApiMarketService implements IMarketService {
 			return cache.markets;
 		}
 
-		const api = useRevenexxApi();
-		const { items } = await api.get<ApiListPage<ApiMarketRow>>("/v1/markets");
+		const sdk = useRevenexxSdk();
+		const { items } = await sdk.markets.marketsList() as unknown as ApiListPage<ApiMarketRow>;
 		const active = items
 			.filter(m => m.status === "active")
 			.sort((a, b) => a.position - b.position || a.code.localeCompare(b.code));
 
 		const markets = await Promise.all(active.map(async (market): Promise<ShopMarket> => {
-			const { items: locales } = await api.get<ApiListPage<ApiLocaleRow>>(
-				`/v1/markets/${encodeURIComponent(market.id)}/locales`,
-			);
+			const { items: locales } = await sdk.markets.marketsLocalesList({ marketId: market.id }) as unknown as ApiListPage<ApiLocaleRow>;
 			return {
 				id: market.id,
 				code: market.code,

package/server/utils/accountService.ts

@@ -1,19 +1,18 @@
 import type { H3Event } from "h3";
 
 import type { IAccountService } from "../interfaces/account";
+import { ApiAccountService } from "../services/ApiAccountService";
 import { MockAccountService } from "../services/MockAccountService";
-import { SdkAccountService } from "../services/SdkAccountService";
 
 /**
  * Registry of available account service implementations.
  * The active implementation is selected by the `accountService` key in app.config.ts:
  * - "mock" — demo identity from the bundled config asset
- * - "sdk"  — live identity via the revenexx web SDK (requires NUXT_WEB_SDK_*
- *            runtime config and an authenticated session)
+ * - "api"  — live identity via the public revenexx API (customers app)
  */
 const serviceRegistry: Record<string, IAccountService> = {
 	mock: new MockAccountService("account/user.json"),
-	sdk: new SdkAccountService(),
+	api: new ApiAccountService(),
 };
 
 /**
@@ -24,7 +23,7 @@ export function getAccountService(event?: H3Event): IAccountService {
 	const key = resolveServiceKey(event, {
 		domain: "accountService",
 		mockKey: "mock",
-		liveKey: "sdk",
+		liveKey: "api",
 	});
 	return serviceRegistry[key] ?? serviceRegistry["mock"]!;
 }

package/server/utils/authService.ts

@@ -3,20 +3,17 @@ import type { H3Event } from "h3";
 import type { IAuthService } from "../interfaces/auth";
 import { ApiAuthService } from "../services/ApiAuthService";
 import { MockAuthService } from "../services/MockAuthService";
-import { SdkAuthService } from "../services/SdkAuthService";
 
 /**
  * Registry of available auth implementations:
  * - "mock" — offline login as bundled B2B demo personas (buyer/approver/admin)
  * - "api"  — live authentication via the public revenexx API (customers app)
- * - "sdk"  — live authentication via the revenexx web SDK (direct platform)
  */
 const mockAuthService = new MockAuthService("account/personas.json");
 
 const serviceRegistry: Record<string, IAuthService> = {
 	mock: mockAuthService,
 	api: new ApiAuthService(),
-	sdk: new SdkAuthService(),
 };
 
 export function getAuthService(event?: H3Event): IAuthService {

package/server/utils/liveCatalog.ts

@@ -1,3 +1,5 @@
+import { Collection } from "@revenexx/sdk";
+
 import type { ProductCategory, ProductSubcategory } from "../../app/config/navigation";
 import type { Product } from "../../app/composables/useProducts";
 import type { ProductDetail } from "../../app/interfaces/product-detail";
@@ -58,16 +60,22 @@ const LIVE_DEFAULT_TAX_RATE = 19;
 const LIVE_DEFAULT_STOCK = { quantity: 9999, maxOrderQuantity: 999999 };
 
 export async function searchLiveProducts(params: LiveSearchParams): Promise<LiveSearchResponse> {
-	return useRevenexxApi().get<LiveSearchResponse>(
-		"/v1/search/collections/products/documents/search",
+	// Raw call (GET form): the gateway currently 404s the POST search route
+	// its spec declares, and the GET contract does not declare facet_by —
+	// the generated search methods can't cover this call yet.
+	return useRevenexxSdk().call<LiveSearchResponse>(
+		"GET",
+		`/v1/search/collections/${Collection.Products}/documents/search`,
 		{
-			q: params.q,
-			query_by: params.queryBy ?? "name,sku,description,manufacturer",
-			filter_by: params.filterBy,
-			facet_by: params.facetBy,
-			sort_by: params.sortBy,
-			page: params.page ?? 1,
-			per_page: params.perPage ?? 24,
+			query: {
+				q: params.q,
+				query_by: params.queryBy ?? "name,sku,description,manufacturer",
+				filter_by: params.filterBy,
+				facet_by: params.facetBy,
+				sort_by: params.sortBy,
+				page: params.page ?? 1,
+				per_page: params.perPage ?? 24,
+			},
 		},
 	);
 }
@@ -174,14 +182,15 @@ async function loadLiveCategoryRows(): Promise<LiveCategoryRow[]> {
 		return categoryCache.rows;
 	}
 
-	const api = useRevenexxApi();
+	const sdk = useRevenexxSdk();
 	const rows: LiveCategoryRow[] = [];
 	let offset = 0;
 	// Paginate defensively — the demo tenant has a few hundred categories.
+	// Raw call: the categories list contract does not declare limit/offset
+	// yet, so the generated productsCategoriesList() cannot paginate.
 	for (let pageIndex = 0; pageIndex < 25; pageIndex++) {
-		const page = await api.get<LiveCategoryPage>("/v1/products/categories", {
-			limit: CATEGORY_PAGE_LIMIT,
-			offset,
+		const page = await sdk.call<LiveCategoryPage>("GET", "/v1/products/categories", {
+			query: { limit: CATEGORY_PAGE_LIMIT, offset },
 		});
 		rows.push(...page.items);
 		if (!page.page.hasMore) {

package/server/utils/liveInventories.ts

@@ -1,4 +1,5 @@
 import type { H3Event } from "h3";
+import type { Models } from "@revenexx/sdk";
 
 import type { Product } from "../../app/composables/useProducts";
 import type { ProductDetail } from "../../app/interfaces/product-detail";
@@ -30,10 +31,9 @@ function toStock(entry: ItemAvailability): { quantity: number; maxOrderQuantity:
 }
 
 async function fetchAvailability(items: Array<{ product_id?: string; sku?: string }>): Promise<Map<string, ItemAvailability>> {
-	const { availability } = await useRevenexxApi().post<{ availability: ItemAvailability[] }>(
-		"/v1/inventories/availability",
-		{ items },
-	);
+	const { availability } = await useRevenexxSdk().inventories.inventoriesAvailability({
+		items: items as Models.InventoryAvailabilityItem[],
+	}) as unknown as { availability: ItemAvailability[] };
 	const byKey = new Map<string, ItemAvailability>();
 	for (const entry of availability) {
 		if (entry.product_id) byKey.set(entry.product_id, entry);

package/server/utils/liveOrders.ts

@@ -129,11 +129,13 @@ export function mapLiveOrderToAccount(order: LiveOrder): AccountOrder {
 
 /** Fetch one live order by its display number (the account history id). */
 export async function getLiveOrderByNumber(number: string): Promise<LiveOrder | null> {
-	const api = useRevenexxApi();
-	const { items } = await api.get<{ items: LiveOrder[] }>("/v1/orders", { number, limit: 1 });
+	const sdk = useRevenexxSdk();
+	// Raw call: orders.list does not declare its query parameters in the
+	// contract yet, so the generated ordersList() cannot filter by number.
+	const { items } = await sdk.call<{ items: LiveOrder[] }>("GET", "/v1/orders", { query: { number, limit: 1 } });
 	const row = items[0];
 	if (!row) {
 		return null;
 	}
-	return api.get<LiveOrder>(`/v1/orders/${row.id}`);
+	return await sdk.orders.ordersGet({ id: row.id }) as unknown as LiveOrder;
 }

package/server/utils/livePrices.ts

@@ -1,4 +1,5 @@
 import type { H3Event } from "h3";
+import type { Models } from "@revenexx/sdk";
 
 import type { StoredSession } from "../../app/interfaces/auth";
 import type { Product } from "../../app/composables/useProducts";
@@ -21,7 +22,7 @@ interface ResolvedPrice {
 }
 
 /** The buyer's price scope from the session (guests resolve openly). */
-function priceContext(event: H3Event): { contact_id?: string; organization_id?: string } {
+function priceContext(event: H3Event): { contactId?: string; organizationId?: string } {
 	const raw = getCookie(event, SESSION_COOKIE_NAME);
 	if (!raw) {
 		return {};
@@ -29,8 +30,8 @@ function priceContext(event: H3Event): { contact_id?: string; organization_id?:
 	try {
 		const parsed = JSON.parse(raw) as StoredSession;
 		return {
-			...(parsed.contactId ? { contact_id: parsed.contactId } : {}),
-			...(parsed.organizationId ? { organization_id: parsed.organizationId } : {}),
+			...(parsed.contactId ? { contactId: parsed.contactId } : {}),
+			...(parsed.organizationId ? { organizationId: parsed.organizationId } : {}),
 		};
 	}
 	catch {
@@ -61,10 +62,10 @@ export async function enrichProductsWithLivePrices(event: H3Event, products: Pro
 	if (products.length === 0) {
 		return products;
 	}
-	const { prices } = await useRevenexxApi().post<{ prices: ResolvedPrice[] }>("/v1/prices/resolve", {
-		items: products.map(p => ({ product_id: p.id, sku: p.sku, quantity: 1 })),
+	const { prices } = await useRevenexxSdk().prices.pricesResolve({
+		items: products.map(p => ({ product_id: p.id, sku: p.sku, quantity: 1 })) as Models.PriceResolveItem[],
 		...priceContext(event),
-	});
+	}) as unknown as { prices: ResolvedPrice[] };
 
 	const byKey = new Map<string, ResolvedPrice>();
 	for (const price of prices) {
@@ -84,10 +85,10 @@ export async function enrichDetailWithLivePrices(event: H3Event, detail: Product
 	if (!product) {
 		return detail;
 	}
-	const { prices } = await useRevenexxApi().post<{ prices: ResolvedPrice[] }>("/v1/prices/resolve", {
-		items: [{ product_id: product.id, sku: product.sku, quantity: 1 }],
+	const { prices } = await useRevenexxSdk().prices.pricesResolve({
+		items: [{ product_id: product.id, sku: product.sku, quantity: 1 }] as Models.PriceResolveItem[],
 		...priceContext(event),
-	});
+	}) as unknown as { prices: ResolvedPrice[] };
 	const resolved = prices[0];
 	return { ...detail, prices: resolved ? toPriceMap(resolved) : [] };
 }

package/server/utils/revenexxSdk.ts

@@ -0,0 +1,162 @@
+import {
+	Carts,
+	Client,
+	Customers,
+	Inventories,
+	Markets,
+	Orders,
+	Payments,
+	Prices,
+	Products,
+	RevenexxException,
+	Search,
+	Shipping,
+} from "@revenexx/sdk";
+
+/**
+ * The generated revenexx web SDK, configured for the BFF. Every live
+ * "api"-keyed implementation goes through these service instances.
+ *
+ * Auth model: tenant API key (server-side only, never reaches the client).
+ * Configure via runtime config / env:
+ *   NUXT_REVENEXX_API_URL   (default https://api.revenexx.com)
+ *   NUXT_REVENEXX_TENANT    (tenant slug, e.g. "revenexx")
+ *   NUXT_REVENEXX_API_KEY   (rvxk_… gateway key)
+ */
+
+// Re-exported so route handlers can narrow SDK failures without importing
+// from the package themselves (Nitro auto-imports this util's exports).
+export { RevenexxException };
+
+export interface RevenexxSdkCallOptions {
+	readonly query?: Record<string, string | number | boolean | undefined>;
+	readonly body?: unknown;
+}
+
+export interface RevenexxSdk {
+	readonly client: Client;
+	readonly carts: Carts;
+	readonly customers: Customers;
+	readonly inventories: Inventories;
+	readonly markets: Markets;
+	readonly orders: Orders;
+	readonly payments: Payments;
+	readonly prices: Prices;
+	readonly products: Products;
+	readonly search: Search;
+	readonly shipping: Shipping;
+	/**
+	 * Low-level escape hatch over the SDK transport (same auth, same error
+	 * type) for the few operations whose gateway contracts are not complete
+	 * yet — list query parameters and auth/me's session check. Each call
+	 * site documents the missing contract piece; once the apps declare it
+	 * and the SDK regenerates, the call moves to the typed method.
+	 */
+	call<T>(method: "GET" | "POST" | "PUT" | "DELETE", path: string, options?: RevenexxSdkCallOptions): Promise<T>;
+}
+
+/**
+ * Expected user-facing failures (wrong credentials, duplicate email, …) are
+ * forwarded to the client as-is; everything else is an infrastructure error.
+ */
+const API_USER_ERROR_STATUS = new Set([400, 401, 404, 409, 429]);
+
+export function isApiUserError(err: unknown): err is RevenexxException {
+	return err instanceof RevenexxException && API_USER_ERROR_STATUS.has(err.code);
+}
+
+/**
+ * The customers app's auth passthrough answers with a generic error envelope
+ * (no machine type). Map the HTTP status onto the platform error types the
+ * client-side auth store already translates, so mock/api modes produce
+ * identical UX for the standard failures.
+ */
+export function apiAuthErrorType(err: RevenexxException): string {
+	switch (err.code) {
+		case 401: return "user_invalid_credentials";
+		case 404: return "user_not_found";
+		case 409: return "user_email_already_exists";
+		case 429: return "general_rate_limit_exceeded";
+		default: return err.type || "api_error";
+	}
+}
+
+/** Diagnostic fields for structured logs — never includes the API key. */
+export function apiErrorContext(err: unknown): Record<string, unknown> {
+	if (err instanceof RevenexxException) {
+		return { apiStatus: err.code, apiType: err.type, apiMessage: err.message };
+	}
+	return { errorMessage: err instanceof Error ? err.message : String(err) };
+}
+
+let sdk: RevenexxSdk | null = null;
+
+export function useRevenexxSdk(): RevenexxSdk {
+	if (sdk) {
+		return sdk;
+	}
+
+	const config = useRuntimeConfig();
+	const endpoint = String(config.revenexxApiUrl || "https://api.revenexx.com").replace(/\/+$/, "");
+	const tenant = String(config.revenexxTenant || "");
+	const apiKey = String(config.revenexxApiKey || "");
+
+	if (!tenant || !apiKey) {
+		throw new RevenexxException(
+			"revenexx API credentials are not configured (NUXT_REVENEXX_TENANT / NUXT_REVENEXX_API_KEY)",
+			503,
+			"api_not_configured",
+			"",
+		);
+	}
+
+	const client = new Client()
+		.setEndpoint(endpoint)
+		.setTenant(tenant)
+		.setApiKeyAuth(apiKey);
+
+	async function call<T>(
+		method: "GET" | "POST" | "PUT" | "DELETE",
+		path: string,
+		options: RevenexxSdkCallOptions = {},
+	): Promise<T> {
+		const url = new URL(endpoint + path);
+		const query: Record<string, string> = {};
+		for (const [key, value] of Object.entries(options.query ?? {})) {
+			if (value !== undefined) {
+				query[key] = String(value);
+			}
+		}
+
+		if (method === "GET") {
+			// client.call appends flattened params to the URL for GET requests
+			return await client.call("get", url, {}, query) as T;
+		}
+
+		for (const [key, value] of Object.entries(query)) {
+			url.searchParams.set(key, value);
+		}
+		return await client.call(
+			method.toLowerCase(),
+			url,
+			{ "content-type": "application/json" },
+			(options.body ?? {}) as never,
+		) as T;
+	}
+
+	sdk = {
+		client,
+		carts: new Carts(client),
+		customers: new Customers(client),
+		inventories: new Inventories(client),
+		markets: new Markets(client),
+		orders: new Orders(client),
+		payments: new Payments(client),
+		prices: new Prices(client),
+		products: new Products(client),
+		search: new Search(client),
+		shipping: new Shipping(client),
+		call,
+	};
+	return sdk;
+}

package/app/validations/companyName.ts

@@ -1,18 +0,0 @@
-import type { SimpleValidator } from "./types";
-
-// checks if the input is a valid company name (basic validation)
-export const companyName: SimpleValidator = (value) => {
-	const companyNameRegex = /^[a-zA-Z0-9äöüÄÖÜß\s.,'-]+$/;
-
-	if (typeof value !== "string") {
-		return null; // Not a string, let other validators handle this
-	}
-
-	const trimmedValue = value.trim();
-
-	if (!companyNameRegex.test(trimmedValue)) {
-		return "invalidCompanyName"; // Invalid company name format
-	}
-
-	return null; // Valid company name
-};

package/app/validations/maxLength.ts

@@ -1,12 +0,0 @@
-import type { SimpleValidator } from "./types";
-
-export const maxLength: SimpleValidator = (value, options) => {
-	const max = (options?.max as number) ?? Infinity;
-	if (typeof value !== "string") {
-		return null;
-	}
-	if (value.trim().length > max) {
-		return "maxLength";
-	}
-	return null;
-};

package/app/validations/optionalCompanyName.ts

@@ -1,23 +0,0 @@
-import type { SimpleValidator } from "./types";
-
-// Validates company name only when a value is present — field is optional.
-// Options { min, max } are forwarded to minLength/maxLength translation keys.
-export const optionalCompanyName: SimpleValidator = (value) => {
-	if (typeof value !== "string" || value.trim() === "") {
-		return null;
-	}
-	const trimmed = value.trim();
-	const min = 3;
-	const max = 64;
-	if (trimmed.length < min) {
-		return "minLength";
-	}
-	if (trimmed.length > max) {
-		return "maxLength";
-	}
-	const companyNameRegex = /^[a-zA-Z0-9äöüÄÖÜß\s.,'-]+$/;
-	if (!companyNameRegex.test(trimmed)) {
-		return "invalidCompanyName";
-	}
-	return null;
-};

package/app/validations/phoneNumber.ts

@@ -1,19 +0,0 @@
-import type { SimpleValidator } from "./types";
-
-// checks if the input is a valid phone number (basic validation)
-export const phoneNumber: SimpleValidator = (value) => {
-	if (typeof value !== "string") {
-		return null; // Not a string, let other validators handle this
-	}
-
-	const trimmedValue = value.trim();
-
-	// Basic regex for phone numbers (allows digits, spaces, dashes, parentheses, and plus sign)
-	const phoneRegex = /^[+\d]?(?:[\d\s-().]*)$/;
-
-	if (!phoneRegex.test(trimmedValue)) {
-		return "invalidPhoneNumber"; // Invalid phone number format
-	}
-
-	return null; // Valid phone number
-};

package/app/validations/termsRequired.ts

@@ -1,4 +0,0 @@
-import type { SimpleValidator } from "./types";
-
-export const termsRequired: SimpleValidator = value =>
-	value !== true ? "termsRequired" : null;

package/app/validations/zipCode.ts

@@ -1,15 +0,0 @@
-import type { SimpleValidator } from "./types";
-
-export const zipCode: SimpleValidator = (value) => {
-	if (typeof value !== "string") {
-		return "invalidZipCode";
-	}
-	const trimmed = value.trim();
-	if (!/^\d{3,5}$/.test(trimmed)) {
-		return "invalidZipCode";
-	}
-	if (/^0+$/.test(trimmed) || trimmed === "99999") {
-		return "invalidZipCode";
-	}
-	return null;
-};