@86d-app/products 0.0.3

package/src/store/endpoints/get-category.ts

@@ -0,0 +1,61 @@
+import { createStoreEndpoint, z } from "@86d-app/core";
+import type { Category, Product } from "../../controllers";
+
+export const getCategory = createStoreEndpoint(
+	"/categories/:id",
+	{
+		method: "GET",
+		params: z.object({
+			id: z.string(),
+		}),
+		query: z
+			.object({
+				includeProducts: z.string().optional(),
+			})
+			.optional(),
+	},
+	async (ctx) => {
+		const { params, query = {} } = ctx;
+		const controllers = ctx.context.controllers;
+
+		// Try to get by ID first
+		let category = (await controllers.category.getById(ctx)) as Category | null;
+
+		// If not found, try by slug
+		if (!category) {
+			category = (await controllers.category.getBySlug({
+				...ctx,
+				query: { slug: params.id },
+			})) as Category | null;
+		}
+
+		if (!category) {
+			return {
+				error: "Category not found",
+				status: 404,
+			};
+		}
+
+		// Only return visible categories to store
+		if (!category.isVisible) {
+			return {
+				error: "Category not found",
+				status: 404,
+			};
+		}
+
+		// Optionally include products
+		let products: unknown[] | undefined;
+		if (query.includeProducts === "true") {
+			products = (await controllers.product.getByCategory({
+				...ctx,
+				params: { categoryId: category.id },
+			})) as Product[];
+		}
+
+		return {
+			category,
+			products,
+		};
+	},
+);

package/src/store/endpoints/get-collection.ts

@@ -0,0 +1,46 @@
+import { createStoreEndpoint, z } from "@86d-app/core";
+import type { Collection, CollectionWithProducts } from "../../controllers";
+
+export const getCollection = createStoreEndpoint(
+	"/collections/:id",
+	{
+		method: "GET",
+		params: z.object({
+			id: z.string(),
+		}),
+	},
+	async (ctx) => {
+		const { params } = ctx;
+		const controllers = ctx.context.controllers;
+
+		// Try by ID first
+		let collection = (await controllers.collection.getWithProducts(
+			ctx,
+		)) as CollectionWithProducts | null;
+
+		// If not found, try by slug
+		if (!collection) {
+			const bySlug = (await controllers.collection.getBySlug({
+				...ctx,
+				query: { slug: params.id },
+			})) as Collection | null;
+			if (bySlug) {
+				collection = (await controllers.collection.getWithProducts({
+					...ctx,
+					params: { id: bySlug.id },
+				})) as CollectionWithProducts | null;
+			}
+		}
+
+		if (!collection) {
+			return { error: "Collection not found", status: 404 };
+		}
+
+		// Only return visible collections to store
+		if (!collection.isVisible) {
+			return { error: "Collection not found", status: 404 };
+		}
+
+		return { collection };
+	},
+);

package/src/store/endpoints/get-featured.ts

@@ -0,0 +1,18 @@
+import { createStoreEndpoint, z } from "@86d-app/core";
+
+export const getFeaturedProducts = createStoreEndpoint(
+	"/products/featured",
+	{
+		method: "GET",
+		query: z
+			.object({
+				limit: z.string().optional(),
+			})
+			.optional(),
+	},
+	async (ctx) => {
+		// Call the controller directly
+		const products = await ctx.context.controllers.product.getFeatured(ctx);
+		return { products };
+	},
+);

package/src/store/endpoints/get-product.ts

@@ -0,0 +1,52 @@
+import { createStoreEndpoint, z } from "@86d-app/core";
+import type { Product, ProductWithVariants } from "../../controllers";
+
+export const getProduct = createStoreEndpoint(
+	"/products/:id",
+	{
+		method: "GET",
+		params: z.object({
+			id: z.string(),
+		}),
+	},
+	async (ctx) => {
+		const { params } = ctx;
+		const controllers = ctx.context.controllers;
+
+		// Try to get by ID first
+		let product = (await controllers.product.getWithVariants(
+			ctx,
+		)) as ProductWithVariants | null;
+
+		// If not found, try by slug
+		if (!product) {
+			const bySlug = (await controllers.product.getBySlug({
+				...ctx,
+				query: { slug: params.id },
+			})) as Product | null;
+			if (bySlug) {
+				product = (await controllers.product.getWithVariants({
+					...ctx,
+					params: { id: bySlug.id },
+				})) as ProductWithVariants | null;
+			}
+		}
+
+		if (!product) {
+			return {
+				error: "Product not found",
+				status: 404,
+			};
+		}
+
+		// Only return active products to store
+		if (product.status !== "active") {
+			return {
+				error: "Product not found",
+				status: 404,
+			};
+		}
+
+		return { product };
+	},
+);

package/src/store/endpoints/get-related.ts

@@ -0,0 +1,20 @@
+import { createStoreEndpoint, z } from "@86d-app/core";
+
+export const getRelatedProducts = createStoreEndpoint(
+	"/products/:id/related",
+	{
+		method: "GET",
+		params: z.object({
+			id: z.string(),
+		}),
+		query: z
+			.object({
+				limit: z.string().optional(),
+			})
+			.optional(),
+	},
+	async (ctx) => {
+		const result = await ctx.context.controllers.product.getRelated(ctx);
+		return result;
+	},
+);

package/src/store/endpoints/index.ts

@@ -0,0 +1,23 @@
+import { getCategory } from "./get-category";
+import { getCollection } from "./get-collection";
+import { getFeaturedProducts } from "./get-featured";
+import { getProduct } from "./get-product";
+import { getRelatedProducts } from "./get-related";
+import { listCategories } from "./list-categories";
+import { listCollections } from "./list-collections";
+import { listProducts } from "./list-products";
+import { searchProducts } from "./search-products";
+import { storeSearch } from "./store-search";
+
+export const storeEndpoints = {
+	"/products": listProducts,
+	"/products/featured": getFeaturedProducts,
+	"/products/search": searchProducts,
+	"/products/store-search": storeSearch,
+	"/products/:id": getProduct,
+	"/products/:id/related": getRelatedProducts,
+	"/categories": listCategories,
+	"/categories/:id": getCategory,
+	"/collections": listCollections,
+	"/collections/:id": getCollection,
+};

package/src/store/endpoints/list-categories.ts

@@ -0,0 +1,13 @@
+import { createStoreEndpoint } from "@86d-app/core";
+
+export const listCategories = createStoreEndpoint(
+	"/categories",
+	{
+		method: "GET",
+	},
+	async (ctx) => {
+		// Call the controller directly to get category tree
+		const categories = await ctx.context.controllers.category.getTree(ctx);
+		return { categories };
+	},
+);

package/src/store/endpoints/list-collections.ts

@@ -0,0 +1,22 @@
+import { createStoreEndpoint, z } from "@86d-app/core";
+
+export const listCollections = createStoreEndpoint(
+	"/collections",
+	{
+		method: "GET",
+		query: z
+			.object({
+				page: z.string().optional(),
+				limit: z.string().optional(),
+				featured: z.string().optional(),
+			})
+			.optional(),
+	},
+	async (ctx) => {
+		const result = await ctx.context.controllers.collection.list({
+			...ctx,
+			query: { ...ctx.query, visible: "true" },
+		});
+		return result;
+	},
+);

package/src/store/endpoints/list-products.ts

@@ -0,0 +1,28 @@
+import { createStoreEndpoint, z } from "@86d-app/core";
+
+export const listProducts = createStoreEndpoint(
+	"/products",
+	{
+		method: "GET",
+		query: z
+			.object({
+				page: z.string().optional(),
+				limit: z.string().optional(),
+				category: z.string().optional(),
+				featured: z.string().optional(),
+				search: z.string().optional(),
+				sort: z.enum(["name", "price", "createdAt", "updatedAt"]).optional(),
+				order: z.enum(["asc", "desc"]).optional(),
+				minPrice: z.string().optional(),
+				maxPrice: z.string().optional(),
+				inStock: z.string().optional(),
+				tag: z.string().optional(),
+			})
+			.optional(),
+	},
+	async (ctx) => {
+		// Call the controller directly - it handles query parsing internally
+		const result = await ctx.context.controllers.product.list(ctx);
+		return result;
+	},
+);

package/src/store/endpoints/search-products.ts

@@ -0,0 +1,18 @@
+import { createStoreEndpoint, z } from "@86d-app/core";
+
+export const searchProducts = createStoreEndpoint(
+	"/products/search",
+	{
+		method: "GET",
+		query: z.object({
+			q: z.string().min(1).max(500),
+			limit: z.string().optional(),
+		}),
+	},
+	async (ctx) => {
+		const { query } = ctx;
+		// Call the controller directly
+		const products = await ctx.context.controllers.product.search(ctx);
+		return { products, query: query.q };
+	},
+);

package/src/store/endpoints/store-search.ts

@@ -0,0 +1,111 @@
+import { createStoreEndpoint, z } from "@86d-app/core";
+import type { Collection, Product } from "../../controllers";
+
+/** Quick links shown in store command search (label and href). */
+const QUICK_LINKS = [
+	{ id: "products", label: "All products", href: "/products", group: "Pages" },
+	{
+		id: "collections",
+		label: "Collections",
+		href: "/collections",
+		group: "Pages",
+	},
+	{ id: "blog", label: "Blog", href: "/blog", group: "Pages" },
+	{ id: "about", label: "About", href: "/about", group: "Pages" },
+	{ id: "contact", label: "Contact", href: "/contact", group: "Pages" },
+	{ id: "terms", label: "Terms", href: "/terms", group: "Pages" },
+	{ id: "privacy", label: "Privacy", href: "/privacy", group: "Pages" },
+	{ id: "account", label: "Account", href: "/account", group: "Account" },
+	{
+		id: "profile",
+		label: "Profile",
+		href: "/account/profile",
+		group: "Account",
+	},
+	{
+		id: "addresses",
+		label: "Addresses",
+		href: "/account/addresses",
+		group: "Account",
+	},
+];
+
+export const storeSearch = createStoreEndpoint(
+	"/products/store-search",
+	{
+		method: "GET",
+		query: z.object({
+			q: z.string().min(0).max(500),
+			limit: z.string().optional(),
+		}),
+	},
+	async (ctx) => {
+		const { query } = ctx;
+		const q = query.q.trim();
+		const limit = query.limit ? parseInt(query.limit, 10) : 15;
+		const queryLower = q.toLowerCase();
+
+		const results: Array<{
+			id: string;
+			label: string;
+			href: string;
+			image?: string;
+			subtitle?: string;
+			group?: string;
+		}> = [];
+
+		if (q.length > 0) {
+			const [products, collections] = (await Promise.all([
+				ctx.context.controllers.product.search({
+					...ctx,
+					query: { q, limit: String(Math.min(limit, 8)) },
+				}),
+				ctx.context.controllers.collection.search({
+					...ctx,
+					query: { q, limit: String(Math.min(limit, 5)) },
+				}),
+			])) as [Product[], Collection[]];
+
+			for (const p of products) {
+				const image = p.images?.[0];
+				results.push({
+					id: `product-${p.id}`,
+					label: p.name,
+					href: `/products/${p.slug}`,
+					...(image ? { image } : {}),
+					...(p.price != null ? { subtitle: formatCents(p.price) } : {}),
+					group: "Products",
+				});
+			}
+			for (const c of collections) {
+				results.push({
+					id: `collection-${c.id}`,
+					label: c.name,
+					href: `/collections/${c.slug}`,
+					...(c.image ? { image: c.image } : {}),
+					group: "Collections",
+				});
+			}
+		}
+
+		for (const link of QUICK_LINKS) {
+			if (q.length === 0 || link.label.toLowerCase().includes(queryLower)) {
+				results.push({
+					id: link.id,
+					label: link.label,
+					href: link.href,
+					group: link.group,
+				});
+			}
+		}
+
+		return { results };
+	},
+);
+
+function formatCents(cents: number): string {
+	return new Intl.NumberFormat("en-US", {
+		style: "currency",
+		currency: "USD",
+	}).format(cents / 100);
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+	"extends": "../../tsconfig.base.json",
+	"compilerOptions": {
+		"lib": ["ES2022", "dom", "dom.iterable"],
+		"jsx": "preserve"
+	},
+	"include": ["src"],
+	"exclude": ["node_modules"]
+}

package/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+	test: {
+		environment: "node",
+	},
+});