@86d-app/products 0.0.3

package/src/admin/components/product-new.tsx

@@ -0,0 +1,38 @@
+"use client";
+
+import { ProductForm } from "./product-form";
+
+export function ProductNew() {
+	return (
+		<div>
+			<div className="mb-6 flex items-center gap-3">
+				<a
+					href="/admin/products"
+					className="text-muted-foreground transition-colors hover:text-foreground"
+				>
+					<svg
+						xmlns="http://www.w3.org/2000/svg"
+						width="20"
+						height="20"
+						viewBox="0 0 24 24"
+						fill="none"
+						stroke="currentColor"
+						strokeWidth="2"
+						strokeLinecap="round"
+						strokeLinejoin="round"
+						aria-hidden="true"
+					>
+						<path d="m15 18-6-6 6-6" />
+					</svg>
+					<span className="sr-only">Back to products</span>
+				</a>
+				<h1 className="font-semibold text-foreground text-lg">New product</h1>
+			</div>
+			<ProductForm
+				onNavigate={(path) => {
+					window.location.href = path;
+				}}
+			/>
+		</div>
+	);
+}

package/src/admin/endpoints/add-collection-product.ts

@@ -0,0 +1,17 @@
+import { createAdminEndpoint, z } from "@86d-app/core";
+
+export const addCollectionProduct = createAdminEndpoint(
+	"/admin/collections/:id/products",
+	{
+		method: "POST",
+		params: z.object({ id: z.string() }),
+		body: z.object({
+			productId: z.string().min(1),
+			position: z.number().int().min(0).optional(),
+		}),
+	},
+	async (ctx) => {
+		const link = await ctx.context.controllers.collection.addProduct(ctx);
+		return { link, status: 201 };
+	},
+);

package/src/admin/endpoints/bulk-action.ts

@@ -0,0 +1,43 @@
+import { createAdminEndpoint, z } from "@86d-app/core";
+
+export const bulkAction = createAdminEndpoint(
+	"/admin/products/bulk",
+	{
+		method: "POST",
+		body: z.object({
+			action: z.enum(["updateStatus", "delete"]),
+			ids: z.array(z.string()).min(1),
+			status: z.enum(["draft", "active", "archived"]).optional(),
+		}),
+	},
+	async (ctx) => {
+		const controllers = ctx.context.controllers;
+		const { action, ids, status } = ctx.body as {
+			action: "updateStatus" | "delete";
+			ids: string[];
+			status?: "draft" | "active" | "archived" | undefined;
+		};
+
+		if (action === "updateStatus") {
+			if (!status) {
+				return {
+					error: "Status is required for updateStatus action",
+					status: 400,
+				};
+			}
+			return controllers.bulk.updateStatus({
+				...ctx,
+				body: { ids, status },
+			});
+		}
+
+		if (action === "delete") {
+			return controllers.bulk.deleteMany({
+				...ctx,
+				body: { ids },
+			});
+		}
+
+		return { error: "Unknown action", status: 400 };
+	},
+);

package/src/admin/endpoints/create-category.ts

@@ -0,0 +1,52 @@
+import { createAdminEndpoint, sanitizeText, z } from "@86d-app/core";
+
+export const createCategory = createAdminEndpoint(
+	"/admin/categories",
+	{
+		method: "POST",
+		body: z.object({
+			name: z.string().min(1).max(200).transform(sanitizeText),
+			slug: z.string().min(1).max(200),
+			description: z.string().max(2000).transform(sanitizeText).optional(),
+			parentId: z.string().optional(),
+			image: z.string().optional(),
+			position: z.number().int().min(0).optional(),
+			isVisible: z.boolean().optional(),
+			metadata: z.record(z.string(), z.any()).optional(),
+		}),
+	},
+	async (ctx) => {
+		const { body } = ctx;
+		const controllers = ctx.context.controllers;
+
+		// Check if slug is unique
+		const existingCategory = await controllers.category.getBySlug({
+			...ctx,
+			query: { slug: body.slug },
+		});
+		if (existingCategory) {
+			return {
+				error: "A category with this slug already exists",
+				status: 400,
+			};
+		}
+
+		// If parentId is provided, check if parent exists
+		if (body.parentId) {
+			const parentCategory = await controllers.category.getById({
+				...ctx,
+				params: { id: body.parentId },
+			});
+			if (!parentCategory) {
+				return {
+					error: "Parent category not found",
+					status: 400,
+				};
+			}
+		}
+
+		const category = await controllers.category.create(ctx);
+
+		return { category, status: 201 };
+	},
+);

package/src/admin/endpoints/create-collection.ts

@@ -0,0 +1,35 @@
+import { createAdminEndpoint, sanitizeText, z } from "@86d-app/core";
+
+export const createCollection = createAdminEndpoint(
+	"/admin/collections",
+	{
+		method: "POST",
+		body: z.object({
+			name: z.string().min(1).max(200).transform(sanitizeText),
+			slug: z.string().min(1).max(200),
+			description: z.string().max(5000).transform(sanitizeText).optional(),
+			image: z.string().max(2000).optional(),
+			isFeatured: z.boolean().optional(),
+			isVisible: z.boolean().optional(),
+			position: z.number().int().min(0).optional(),
+		}),
+	},
+	async (ctx) => {
+		const { body } = ctx;
+
+		// Check slug uniqueness
+		const existing = await ctx.context.controllers.collection.getBySlug({
+			...ctx,
+			query: { slug: body.slug },
+		});
+		if (existing) {
+			return {
+				error: "A collection with this slug already exists",
+				status: 400,
+			};
+		}
+
+		const collection = await ctx.context.controllers.collection.create(ctx);
+		return { collection, status: 201 };
+	},
+);

package/src/admin/endpoints/create-product.ts

@@ -0,0 +1,50 @@
+import { createAdminEndpoint, sanitizeText, z } from "@86d-app/core";
+
+export const createProduct = createAdminEndpoint(
+	"/admin/products",
+	{
+		method: "POST",
+		body: z.object({
+			name: z.string().min(1).max(200).transform(sanitizeText),
+			slug: z.string().min(1).max(200),
+			description: z.string().max(10000).transform(sanitizeText).optional(),
+			shortDescription: z.string().max(500).transform(sanitizeText).optional(),
+			price: z.number().positive(),
+			compareAtPrice: z.number().positive().optional(),
+			costPrice: z.number().positive().optional(),
+			sku: z.string().max(100).optional(),
+			barcode: z.string().max(100).optional(),
+			inventory: z.number().int().min(0).optional(),
+			trackInventory: z.boolean().optional(),
+			allowBackorder: z.boolean().optional(),
+			status: z.enum(["draft", "active", "archived"]).optional(),
+			categoryId: z.string().optional(),
+			images: z.array(z.string()).optional(),
+			tags: z.array(z.string()).optional(),
+			metadata: z.record(z.string(), z.any()).optional(),
+			weight: z.number().positive().optional(),
+			weightUnit: z.enum(["kg", "lb", "oz", "g"]).optional(),
+			isFeatured: z.boolean().optional(),
+		}),
+	},
+	async (ctx) => {
+		const { body } = ctx;
+		const controllers = ctx.context.controllers;
+
+		// Check if slug is unique
+		const existingProduct = await controllers.product.getBySlug({
+			...ctx,
+			query: { slug: body.slug },
+		});
+		if (existingProduct) {
+			return {
+				error: "A product with this slug already exists",
+				status: 400,
+			};
+		}
+
+		const product = await controllers.product.create(ctx);
+
+		return { product, status: 201 };
+	},
+);

package/src/admin/endpoints/create-variant.ts

@@ -0,0 +1,45 @@
+import { createAdminEndpoint, sanitizeText, z } from "@86d-app/core";
+
+export const createVariant = createAdminEndpoint(
+	"/admin/products/:productId/variants",
+	{
+		method: "POST",
+		params: z.object({
+			productId: z.string(),
+		}),
+		body: z.object({
+			name: z.string().min(1).max(200).transform(sanitizeText),
+			sku: z.string().max(100).optional(),
+			barcode: z.string().max(100).optional(),
+			price: z.number().positive(),
+			compareAtPrice: z.number().positive().optional(),
+			costPrice: z.number().positive().optional(),
+			inventory: z.number().int().min(0).optional(),
+			options: z.record(z.string(), z.string()),
+			images: z.array(z.string()).optional(),
+			weight: z.number().positive().optional(),
+			weightUnit: z.enum(["kg", "lb", "oz", "g"]).optional(),
+			position: z.number().int().min(0).optional(),
+		}),
+	},
+	async (ctx) => {
+		const { params } = ctx;
+		const controllers = ctx.context.controllers;
+
+		// Check if product exists
+		const existingProduct = await controllers.product.getById({
+			...ctx,
+			params: { id: params.productId },
+		});
+		if (!existingProduct) {
+			return {
+				error: "Product not found",
+				status: 404,
+			};
+		}
+
+		const variant = await controllers.variant.create(ctx);
+
+		return { variant, status: 201 };
+	},
+);

package/src/admin/endpoints/delete-category.ts

@@ -0,0 +1,27 @@
+import { createAdminEndpoint, z } from "@86d-app/core";
+
+export const deleteCategory = createAdminEndpoint(
+	"/admin/categories/:id",
+	{
+		method: "DELETE",
+		params: z.object({
+			id: z.string(),
+		}),
+	},
+	async (ctx) => {
+		const controllers = ctx.context.controllers;
+
+		// Check if category exists
+		const existingCategory = await controllers.category.getById(ctx);
+		if (!existingCategory) {
+			return {
+				error: "Category not found",
+				status: 404,
+			};
+		}
+
+		await controllers.category.delete(ctx);
+
+		return { success: true, message: "Category deleted successfully" };
+	},
+);

package/src/admin/endpoints/delete-collection.ts

@@ -0,0 +1,12 @@
+import { createAdminEndpoint, z } from "@86d-app/core";
+
+export const deleteCollection = createAdminEndpoint(
+	"/admin/collections/:id",
+	{
+		method: "DELETE",
+		params: z.object({ id: z.string() }),
+	},
+	async (ctx) => {
+		return ctx.context.controllers.collection.delete(ctx);
+	},
+);

package/src/admin/endpoints/delete-product.ts

@@ -0,0 +1,27 @@
+import { createAdminEndpoint, z } from "@86d-app/core";
+
+export const deleteProduct = createAdminEndpoint(
+	"/admin/products/:id",
+	{
+		method: "DELETE",
+		params: z.object({
+			id: z.string(),
+		}),
+	},
+	async (ctx) => {
+		const controllers = ctx.context.controllers;
+
+		// Check if product exists
+		const existingProduct = await controllers.product.getById(ctx);
+		if (!existingProduct) {
+			return {
+				error: "Product not found",
+				status: 404,
+			};
+		}
+
+		await controllers.product.delete(ctx);
+
+		return { success: true, message: "Product deleted successfully" };
+	},
+);

package/src/admin/endpoints/delete-variant.ts

@@ -0,0 +1,27 @@
+import { createAdminEndpoint, z } from "@86d-app/core";
+
+export const deleteVariant = createAdminEndpoint(
+	"/admin/variants/:id",
+	{
+		method: "DELETE",
+		params: z.object({
+			id: z.string(),
+		}),
+	},
+	async (ctx) => {
+		const controllers = ctx.context.controllers;
+
+		// Check if variant exists
+		const existingVariant = await controllers.variant.getById(ctx);
+		if (!existingVariant) {
+			return {
+				error: "Variant not found",
+				status: 404,
+			};
+		}
+
+		await controllers.variant.delete(ctx);
+
+		return { success: true, message: "Variant deleted successfully" };
+	},
+);

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

@@ -0,0 +1,23 @@
+import { createAdminEndpoint, z } from "@86d-app/core";
+
+export const adminGetProduct = createAdminEndpoint(
+	"/admin/products/:id",
+	{
+		method: "GET",
+		params: z.object({
+			id: z.string(),
+		}),
+	},
+	async (ctx) => {
+		const product = await ctx.context.controllers.product.getWithVariants(ctx);
+
+		if (!product) {
+			return {
+				error: "Product not found",
+				status: 404,
+			};
+		}
+
+		return { product };
+	},
+);

package/src/admin/endpoints/import-products.ts

@@ -0,0 +1,47 @@
+import { createAdminEndpoint, sanitizeText, z } from "@86d-app/core";
+
+export const importProducts = createAdminEndpoint(
+	"/admin/products/import",
+	{
+		method: "POST",
+		body: z.object({
+			products: z
+				.array(
+					z.object({
+						name: z.string().min(1).max(200).transform(sanitizeText),
+						slug: z.string().max(200).optional(),
+						price: z.union([z.number(), z.string()]),
+						sku: z.string().max(100).optional(),
+						barcode: z.string().max(100).optional(),
+						description: z
+							.string()
+							.max(10000)
+							.transform(sanitizeText)
+							.optional(),
+						shortDescription: z
+							.string()
+							.max(500)
+							.transform(sanitizeText)
+							.optional(),
+						compareAtPrice: z.union([z.number(), z.string()]).optional(),
+						costPrice: z.union([z.number(), z.string()]).optional(),
+						inventory: z.union([z.number(), z.string()]).optional(),
+						status: z.enum(["draft", "active", "archived"]).optional(),
+						category: z.string().optional(),
+						tags: z.array(z.string()).optional(),
+						weight: z.union([z.number(), z.string()]).optional(),
+						weightUnit: z.enum(["kg", "lb", "oz", "g"]).optional(),
+						featured: z.boolean().optional(),
+						trackInventory: z.boolean().optional(),
+						allowBackorder: z.boolean().optional(),
+					}),
+				)
+				.min(1)
+				.max(500),
+		}),
+	},
+	async (ctx) => {
+		const result = await ctx.context.controllers.import.importProducts(ctx);
+		return result;
+	},
+);

package/src/admin/endpoints/index.ts

@@ -0,0 +1,43 @@
+import { addCollectionProduct } from "./add-collection-product";
+import { bulkAction } from "./bulk-action";
+import { createCategory } from "./create-category";
+import { createCollection } from "./create-collection";
+import { createProduct } from "./create-product";
+import { createVariant } from "./create-variant";
+import { deleteCategory } from "./delete-category";
+import { deleteCollection } from "./delete-collection";
+import { deleteProduct } from "./delete-product";
+import { deleteVariant } from "./delete-variant";
+import { adminGetProduct } from "./get-product";
+import { importProducts } from "./import-products";
+import { adminListCategories } from "./list-categories";
+import { adminListCollections } from "./list-collections";
+import { adminListProducts } from "./list-products";
+import { removeCollectionProduct } from "./remove-collection-product";
+import { updateCategory } from "./update-category";
+import { updateCollection } from "./update-collection";
+import { updateProduct } from "./update-product";
+import { updateVariant } from "./update-variant";
+
+export const adminEndpoints = {
+	"/admin/products/list": adminListProducts,
+	"/admin/products/create": createProduct,
+	"/admin/products/:id": adminGetProduct,
+	"/admin/products/:id/update": updateProduct,
+	"/admin/products/:id/delete": deleteProduct,
+	"/admin/products/import": importProducts,
+	"/admin/products/bulk": bulkAction,
+	"/admin/products/:productId/variants": createVariant,
+	"/admin/variants/:id/update": updateVariant,
+	"/admin/variants/:id/delete": deleteVariant,
+	"/admin/categories/list": adminListCategories,
+	"/admin/categories/create": createCategory,
+	"/admin/categories/:id/update": updateCategory,
+	"/admin/categories/:id/delete": deleteCategory,
+	"/admin/collections/list": adminListCollections,
+	"/admin/collections/create": createCollection,
+	"/admin/collections/:id/update": updateCollection,
+	"/admin/collections/:id/delete": deleteCollection,
+	"/admin/collections/:id/products": addCollectionProduct,
+	"/admin/collections/:id/products/:productId/remove": removeCollectionProduct,
+};

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

@@ -0,0 +1,21 @@
+import { createAdminEndpoint, z } from "@86d-app/core";
+
+export const adminListCategories = createAdminEndpoint(
+	"/admin/categories",
+	{
+		method: "GET",
+		query: z
+			.object({
+				page: z.string().optional(),
+				limit: z.string().optional(),
+				parent: z.string().optional(),
+				visible: z.string().optional(),
+			})
+			.optional(),
+	},
+	async (ctx) => {
+		// Call the controller directly - it handles query parsing internally
+		const result = await ctx.context.controllers.category.list(ctx);
+		return result;
+	},
+);

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

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

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

@@ -0,0 +1,25 @@
+import { createAdminEndpoint, z } from "@86d-app/core";
+
+export const adminListProducts = createAdminEndpoint(
+	"/admin/products",
+	{
+		method: "GET",
+		query: z
+			.object({
+				page: z.string().optional(),
+				limit: z.string().optional(),
+				category: z.string().optional(),
+				status: z.enum(["draft", "active", "archived"]).optional(),
+				featured: z.string().optional(),
+				search: z.string().optional(),
+				sort: z.enum(["name", "price", "createdAt", "updatedAt"]).optional(),
+				order: z.enum(["asc", "desc"]).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/admin/endpoints/remove-collection-product.ts

@@ -0,0 +1,15 @@
+import { createAdminEndpoint, z } from "@86d-app/core";
+
+export const removeCollectionProduct = createAdminEndpoint(
+	"/admin/collections/:id/products/:productId",
+	{
+		method: "DELETE",
+		params: z.object({
+			id: z.string(),
+			productId: z.string(),
+		}),
+	},
+	async (ctx) => {
+		return ctx.context.controllers.collection.removeProduct(ctx);
+	},
+);

package/src/admin/endpoints/update-category.ts

@@ -0,0 +1,82 @@
+import { createAdminEndpoint, sanitizeText, z } from "@86d-app/core";
+import type { Category } from "../../controllers";
+
+export const updateCategory = createAdminEndpoint(
+	"/admin/categories/:id",
+	{
+		method: "PUT",
+		params: z.object({
+			id: z.string(),
+		}),
+		body: z.object({
+			name: z.string().min(1).max(200).transform(sanitizeText).optional(),
+			slug: z.string().min(1).max(200).optional(),
+			description: z
+				.string()
+				.max(2000)
+				.transform(sanitizeText)
+				.nullable()
+				.optional(),
+			parentId: z.string().nullable().optional(),
+			image: z.string().max(2048).nullable().optional(),
+			position: z.number().int().min(0).optional(),
+			isVisible: z.boolean().optional(),
+			metadata: z.record(z.string(), z.any()).optional(),
+		}),
+	},
+	async (ctx) => {
+		const { params, body } = ctx;
+		const controllers = ctx.context.controllers;
+
+		// Check if category exists
+		const existingCategory = (await controllers.category.getById(
+			ctx,
+		)) as Category | null;
+		if (!existingCategory) {
+			return {
+				error: "Category not found",
+				status: 404,
+			};
+		}
+
+		// If slug is being changed, check uniqueness
+		if (body.slug && body.slug !== existingCategory.slug) {
+			const categoryWithSlug = await controllers.category.getBySlug({
+				...ctx,
+				query: { slug: body.slug },
+			});
+			if (categoryWithSlug) {
+				return {
+					error: "A category with this slug already exists",
+					status: 400,
+				};
+			}
+		}
+
+		// Prevent circular parent reference
+		if (body.parentId === params.id) {
+			return {
+				error: "A category cannot be its own parent",
+				status: 400,
+			};
+		}
+
+		// If parentId is provided, check if parent exists
+		if (body.parentId) {
+			const parentCategory = await controllers.category.getById({
+				...ctx,
+				params: { id: body.parentId },
+			});
+			if (!parentCategory) {
+				return {
+					error: "Parent category not found",
+					status: 400,
+				};
+			}
+		}
+
+		const category = await controllers.category.update(ctx);
+
+		return { category };
+	},
+);