@hasna/microservices 0.0.9 → 0.0.11

package/microservices/microservice-products/src/db/migrations.ts

@@ -0,0 +1,58 @@
+export interface MigrationEntry {
+  id: number;
+  name: string;
+  sql: string;
+}
+
+export const MIGRATIONS: MigrationEntry[] = [
+  {
+    id: 1,
+    name: "initial_schema",
+    sql: `
+      CREATE TABLE IF NOT EXISTS categories (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        parent_id TEXT REFERENCES categories(id) ON DELETE SET NULL,
+        description TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS products (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        description TEXT,
+        type TEXT NOT NULL DEFAULT 'product' CHECK(type IN ('product', 'service', 'subscription', 'digital')),
+        sku TEXT UNIQUE,
+        price REAL,
+        currency TEXT NOT NULL DEFAULT 'USD',
+        unit TEXT,
+        category TEXT,
+        status TEXT NOT NULL DEFAULT 'draft' CHECK(status IN ('active', 'draft', 'archived')),
+        images TEXT NOT NULL DEFAULT '[]',
+        variants TEXT NOT NULL DEFAULT '[]',
+        metadata TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS pricing_tiers (
+        id TEXT PRIMARY KEY,
+        product_id TEXT NOT NULL REFERENCES products(id) ON DELETE CASCADE,
+        name TEXT NOT NULL,
+        min_quantity INTEGER NOT NULL,
+        price REAL NOT NULL,
+        currency TEXT NOT NULL DEFAULT 'USD',
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_products_sku ON products(sku);
+      CREATE INDEX IF NOT EXISTS idx_products_name ON products(name);
+      CREATE INDEX IF NOT EXISTS idx_products_type ON products(type);
+      CREATE INDEX IF NOT EXISTS idx_products_status ON products(status);
+      CREATE INDEX IF NOT EXISTS idx_products_category ON products(category);
+      CREATE INDEX IF NOT EXISTS idx_categories_name ON categories(name);
+      CREATE INDEX IF NOT EXISTS idx_categories_parent ON categories(parent_id);
+      CREATE INDEX IF NOT EXISTS idx_pricing_tiers_product ON pricing_tiers(product_id);
+    `,
+  },
+];

package/microservices/microservice-products/src/db/pricing-tiers.ts

@@ -0,0 +1,66 @@
+/**
+ * Pricing tier operations
+ */
+
+import { getDatabase } from "./database.js";
+
+export interface PricingTier {
+  id: string;
+  product_id: string;
+  name: string;
+  min_quantity: number;
+  price: number;
+  currency: string;
+  created_at: string;
+}
+
+export interface CreatePricingTierInput {
+  product_id: string;
+  name: string;
+  min_quantity: number;
+  price: number;
+  currency?: string;
+}
+
+export function createPricingTier(input: CreatePricingTierInput): PricingTier {
+  const db = getDatabase();
+  const id = crypto.randomUUID();
+
+  db.prepare(
+    `INSERT INTO pricing_tiers (id, product_id, name, min_quantity, price, currency)
+     VALUES (?, ?, ?, ?, ?, ?)`
+  ).run(
+    id,
+    input.product_id,
+    input.name,
+    input.min_quantity,
+    input.price,
+    input.currency || "USD"
+  );
+
+  return getPricingTier(id)!;
+}
+
+export function getPricingTier(id: string): PricingTier | null {
+  const db = getDatabase();
+  return db.prepare("SELECT * FROM pricing_tiers WHERE id = ?").get(id) as PricingTier | null;
+}
+
+export function listPricingTiers(productId: string): PricingTier[] {
+  const db = getDatabase();
+  return db
+    .prepare("SELECT * FROM pricing_tiers WHERE product_id = ? ORDER BY min_quantity")
+    .all(productId) as PricingTier[];
+}
+
+export function deletePricingTier(id: string): boolean {
+  const db = getDatabase();
+  const result = db.prepare("DELETE FROM pricing_tiers WHERE id = ?").run(id);
+  return result.changes > 0;
+}
+
+export function deletePricingTiersByProduct(productId: string): number {
+  const db = getDatabase();
+  const result = db.prepare("DELETE FROM pricing_tiers WHERE product_id = ?").run(productId);
+  return result.changes;
+}

package/microservices/microservice-products/src/db/products.ts

@@ -0,0 +1,452 @@
+/**
+ * Product CRUD operations
+ */
+
+import { getDatabase } from "./database.js";
+
+export interface Product {
+  id: string;
+  name: string;
+  description: string | null;
+  type: "product" | "service" | "subscription" | "digital";
+  sku: string | null;
+  price: number | null;
+  currency: string;
+  unit: string | null;
+  category: string | null;
+  status: "active" | "draft" | "archived";
+  images: string[];
+  variants: Record<string, unknown>[];
+  metadata: Record<string, unknown>;
+  created_at: string;
+  updated_at: string;
+}
+
+interface ProductRow {
+  id: string;
+  name: string;
+  description: string | null;
+  type: string;
+  sku: string | null;
+  price: number | null;
+  currency: string;
+  unit: string | null;
+  category: string | null;
+  status: string;
+  images: string;
+  variants: string;
+  metadata: string;
+  created_at: string;
+  updated_at: string;
+}
+
+function rowToProduct(row: ProductRow): Product {
+  return {
+    ...row,
+    type: row.type as Product["type"],
+    status: row.status as Product["status"],
+    images: JSON.parse(row.images || "[]"),
+    variants: JSON.parse(row.variants || "[]"),
+    metadata: JSON.parse(row.metadata || "{}"),
+  };
+}
+
+export interface CreateProductInput {
+  name: string;
+  description?: string;
+  type?: "product" | "service" | "subscription" | "digital";
+  sku?: string;
+  price?: number;
+  currency?: string;
+  unit?: string;
+  category?: string;
+  status?: "active" | "draft" | "archived";
+  images?: string[];
+  variants?: Record<string, unknown>[];
+  metadata?: Record<string, unknown>;
+}
+
+export function createProduct(input: CreateProductInput): Product {
+  const db = getDatabase();
+  const id = crypto.randomUUID();
+  const images = JSON.stringify(input.images || []);
+  const variants = JSON.stringify(input.variants || []);
+  const metadata = JSON.stringify(input.metadata || {});
+
+  db.prepare(
+    `INSERT INTO products (id, name, description, type, sku, price, currency, unit, category, status, images, variants, metadata)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    id,
+    input.name,
+    input.description || null,
+    input.type || "product",
+    input.sku || null,
+    input.price ?? null,
+    input.currency || "USD",
+    input.unit || null,
+    input.category || null,
+    input.status || "draft",
+    images,
+    variants,
+    metadata
+  );
+
+  return getProduct(id)!;
+}
+
+export function getProduct(id: string): Product | null {
+  const db = getDatabase();
+  const row = db.prepare("SELECT * FROM products WHERE id = ?").get(id) as ProductRow | null;
+  return row ? rowToProduct(row) : null;
+}
+
+export interface ListProductsOptions {
+  search?: string;
+  category?: string;
+  type?: string;
+  status?: string;
+  limit?: number;
+  offset?: number;
+}
+
+export function listProducts(options: ListProductsOptions = {}): Product[] {
+  const db = getDatabase();
+  const conditions: string[] = [];
+  const params: unknown[] = [];
+
+  if (options.search) {
+    conditions.push(
+      "(name LIKE ? OR description LIKE ? OR sku LIKE ?)"
+    );
+    const q = `%${options.search}%`;
+    params.push(q, q, q);
+  }
+
+  if (options.category) {
+    conditions.push("category = ?");
+    params.push(options.category);
+  }
+
+  if (options.type) {
+    conditions.push("type = ?");
+    params.push(options.type);
+  }
+
+  if (options.status) {
+    conditions.push("status = ?");
+    params.push(options.status);
+  }
+
+  let sql = "SELECT * FROM products";
+  if (conditions.length > 0) {
+    sql += " WHERE " + conditions.join(" AND ");
+  }
+  sql += " ORDER BY name";
+
+  if (options.limit) {
+    sql += " LIMIT ?";
+    params.push(options.limit);
+  }
+  if (options.offset) {
+    sql += " OFFSET ?";
+    params.push(options.offset);
+  }
+
+  const rows = db.prepare(sql).all(...params) as ProductRow[];
+  return rows.map(rowToProduct);
+}
+
+export interface UpdateProductInput {
+  name?: string;
+  description?: string;
+  type?: "product" | "service" | "subscription" | "digital";
+  sku?: string;
+  price?: number;
+  currency?: string;
+  unit?: string;
+  category?: string | null;
+  status?: "active" | "draft" | "archived";
+  images?: string[];
+  variants?: Record<string, unknown>[];
+  metadata?: Record<string, unknown>;
+}
+
+export function updateProduct(
+  id: string,
+  input: UpdateProductInput
+): Product | null {
+  const db = getDatabase();
+  const existing = getProduct(id);
+  if (!existing) return null;
+
+  const sets: string[] = [];
+  const params: unknown[] = [];
+
+  if (input.name !== undefined) {
+    sets.push("name = ?");
+    params.push(input.name);
+  }
+  if (input.description !== undefined) {
+    sets.push("description = ?");
+    params.push(input.description);
+  }
+  if (input.type !== undefined) {
+    sets.push("type = ?");
+    params.push(input.type);
+  }
+  if (input.sku !== undefined) {
+    sets.push("sku = ?");
+    params.push(input.sku);
+  }
+  if (input.price !== undefined) {
+    sets.push("price = ?");
+    params.push(input.price);
+  }
+  if (input.currency !== undefined) {
+    sets.push("currency = ?");
+    params.push(input.currency);
+  }
+  if (input.unit !== undefined) {
+    sets.push("unit = ?");
+    params.push(input.unit);
+  }
+  if (input.category !== undefined) {
+    sets.push("category = ?");
+    params.push(input.category);
+  }
+  if (input.status !== undefined) {
+    sets.push("status = ?");
+    params.push(input.status);
+  }
+  if (input.images !== undefined) {
+    sets.push("images = ?");
+    params.push(JSON.stringify(input.images));
+  }
+  if (input.variants !== undefined) {
+    sets.push("variants = ?");
+    params.push(JSON.stringify(input.variants));
+  }
+  if (input.metadata !== undefined) {
+    sets.push("metadata = ?");
+    params.push(JSON.stringify(input.metadata));
+  }
+
+  if (sets.length === 0) return existing;
+
+  sets.push("updated_at = datetime('now')");
+  params.push(id);
+
+  db.prepare(
+    `UPDATE products SET ${sets.join(", ")} WHERE id = ?`
+  ).run(...params);
+
+  return getProduct(id);
+}
+
+export function deleteProduct(id: string): boolean {
+  const db = getDatabase();
+  const result = db.prepare("DELETE FROM products WHERE id = ?").run(id);
+  return result.changes > 0;
+}
+
+export function countProducts(): number {
+  const db = getDatabase();
+  const row = db.prepare("SELECT COUNT(*) as count FROM products").get() as { count: number };
+  return row.count;
+}
+
+export function searchProducts(query: string): Product[] {
+  return listProducts({ search: query });
+}
+
+export function listByCategory(category: string): Product[] {
+  return listProducts({ category });
+}
+
+export function listByType(type: string): Product[] {
+  return listProducts({ type });
+}
+
+export function listByStatus(status: string): Product[] {
+  return listProducts({ status });
+}
+
+export interface ProductWithTiers extends Product {
+  pricing_tiers: PricingTier[];
+}
+
+export interface PricingTier {
+  id: string;
+  product_id: string;
+  name: string;
+  min_quantity: number;
+  price: number;
+  currency: string;
+  created_at: string;
+}
+
+export function getProductWithTiers(id: string): ProductWithTiers | null {
+  const product = getProduct(id);
+  if (!product) return null;
+
+  const db = getDatabase();
+  const tiers = db
+    .prepare("SELECT * FROM pricing_tiers WHERE product_id = ? ORDER BY min_quantity")
+    .all(id) as PricingTier[];
+
+  return { ...product, pricing_tiers: tiers };
+}
+
+export interface BulkImportResult {
+  imported: number;
+  skipped: number;
+  errors: string[];
+}
+
+export function bulkImportProducts(csv: string): BulkImportResult {
+  const lines = csv.trim().split("\n");
+  if (lines.length < 2) {
+    return { imported: 0, skipped: 0, errors: ["CSV must have a header row and at least one data row"] };
+  }
+
+  const headers = lines[0].split(",").map((h) => h.trim().toLowerCase());
+  const nameIdx = headers.indexOf("name");
+  if (nameIdx === -1) {
+    return { imported: 0, skipped: 0, errors: ["CSV must have a 'name' column"] };
+  }
+
+  const result: BulkImportResult = { imported: 0, skipped: 0, errors: [] };
+
+  for (let i = 1; i < lines.length; i++) {
+    const values = lines[i].split(",").map((v) => v.trim());
+    if (values.length < headers.length) {
+      result.errors.push(`Row ${i + 1}: insufficient columns`);
+      result.skipped++;
+      continue;
+    }
+
+    try {
+      const input: CreateProductInput = {
+        name: values[nameIdx],
+      };
+
+      const descIdx = headers.indexOf("description");
+      if (descIdx !== -1 && values[descIdx]) input.description = values[descIdx];
+
+      const typeIdx = headers.indexOf("type");
+      if (typeIdx !== -1 && values[typeIdx]) {
+        const t = values[typeIdx] as CreateProductInput["type"];
+        if (["product", "service", "subscription", "digital"].includes(values[typeIdx])) {
+          input.type = t;
+        }
+      }
+
+      const skuIdx = headers.indexOf("sku");
+      if (skuIdx !== -1 && values[skuIdx]) input.sku = values[skuIdx];
+
+      const priceIdx = headers.indexOf("price");
+      if (priceIdx !== -1 && values[priceIdx]) {
+        const p = parseFloat(values[priceIdx]);
+        if (!isNaN(p)) input.price = p;
+      }
+
+      const currencyIdx = headers.indexOf("currency");
+      if (currencyIdx !== -1 && values[currencyIdx]) input.currency = values[currencyIdx];
+
+      const unitIdx = headers.indexOf("unit");
+      if (unitIdx !== -1 && values[unitIdx]) input.unit = values[unitIdx];
+
+      const categoryIdx = headers.indexOf("category");
+      if (categoryIdx !== -1 && values[categoryIdx]) input.category = values[categoryIdx];
+
+      const statusIdx = headers.indexOf("status");
+      if (statusIdx !== -1 && values[statusIdx]) {
+        const s = values[statusIdx] as CreateProductInput["status"];
+        if (["active", "draft", "archived"].includes(values[statusIdx])) {
+          input.status = s;
+        }
+      }
+
+      createProduct(input);
+      result.imported++;
+    } catch (error) {
+      result.errors.push(`Row ${i + 1}: ${error instanceof Error ? error.message : String(error)}`);
+      result.skipped++;
+    }
+  }
+
+  return result;
+}
+
+export function exportProducts(format: "csv" | "json" = "json"): string {
+  const products = listProducts();
+
+  if (format === "json") {
+    return JSON.stringify(products, null, 2);
+  }
+
+  // CSV format
+  const headers = [
+    "id", "name", "description", "type", "sku", "price", "currency",
+    "unit", "category", "status", "created_at", "updated_at",
+  ];
+  const rows = products.map((p) =>
+    headers.map((h) => {
+      const val = p[h as keyof Product];
+      if (val === null || val === undefined) return "";
+      if (typeof val === "string" && val.includes(",")) return `"${val}"`;
+      return String(val);
+    }).join(",")
+  );
+
+  return [headers.join(","), ...rows].join("\n");
+}
+
+export interface ProductStats {
+  total: number;
+  by_status: Record<string, number>;
+  by_type: Record<string, number>;
+  by_category: Record<string, number>;
+  avg_price: number | null;
+  min_price: number | null;
+  max_price: number | null;
+}
+
+export function getProductStats(): ProductStats {
+  const db = getDatabase();
+
+  const total = (db.prepare("SELECT COUNT(*) as count FROM products").get() as { count: number }).count;
+
+  const statusRows = db
+    .prepare("SELECT status, COUNT(*) as count FROM products GROUP BY status")
+    .all() as { status: string; count: number }[];
+  const by_status: Record<string, number> = {};
+  for (const r of statusRows) by_status[r.status] = r.count;
+
+  const typeRows = db
+    .prepare("SELECT type, COUNT(*) as count FROM products GROUP BY type")
+    .all() as { type: string; count: number }[];
+  const by_type: Record<string, number> = {};
+  for (const r of typeRows) by_type[r.type] = r.count;
+
+  const catRows = db
+    .prepare("SELECT COALESCE(category, 'uncategorized') as category, COUNT(*) as count FROM products GROUP BY category")
+    .all() as { category: string; count: number }[];
+  const by_category: Record<string, number> = {};
+  for (const r of catRows) by_category[r.category] = r.count;
+
+  const priceRow = db
+    .prepare("SELECT AVG(price) as avg_price, MIN(price) as min_price, MAX(price) as max_price FROM products WHERE price IS NOT NULL")
+    .get() as { avg_price: number | null; min_price: number | null; max_price: number | null };
+
+  return {
+    total,
+    by_status,
+    by_type,
+    by_category,
+    avg_price: priceRow.avg_price,
+    min_price: priceRow.min_price,
+    max_price: priceRow.max_price,
+  };
+}

package/microservices/microservice-products/src/index.ts

@@ -0,0 +1,53 @@
+/**
+ * microservice-products — Product catalog microservice
+ */
+
+export {
+  createProduct,
+  getProduct,
+  listProducts,
+  updateProduct,
+  deleteProduct,
+  countProducts,
+  searchProducts,
+  listByCategory,
+  listByType,
+  listByStatus,
+  getProductWithTiers,
+  bulkImportProducts,
+  exportProducts,
+  getProductStats,
+  type Product,
+  type ProductWithTiers,
+  type CreateProductInput,
+  type UpdateProductInput,
+  type ListProductsOptions,
+  type ProductStats,
+  type BulkImportResult,
+} from "./db/products.js";
+
+export {
+  createCategory,
+  getCategory,
+  listCategories,
+  updateCategory,
+  deleteCategory,
+  getCategoryTree,
+  type Category,
+  type CreateCategoryInput,
+  type UpdateCategoryInput,
+  type ListCategoriesOptions,
+  type CategoryTreeNode,
+} from "./db/categories.js";
+
+export {
+  createPricingTier,
+  getPricingTier,
+  listPricingTiers,
+  deletePricingTier,
+  deletePricingTiersByProduct,
+  type PricingTier,
+  type CreatePricingTierInput,
+} from "./db/pricing-tiers.js";
+
+export { getDatabase, closeDatabase } from "./db/database.js";