@hasna/microservices 0.0.9 → 0.0.11

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

@@ -0,0 +1,370 @@
+/**
+ * Asset and Collection CRUD operations
+ */
+
+import { getDatabase } from "./database.js";
+
+// --- Asset types ---
+
+export interface Asset {
+  id: string;
+  name: string;
+  description: string | null;
+  type: string | null;
+  file_path: string | null;
+  file_size: number | null;
+  mime_type: string | null;
+  dimensions: string | null;
+  tags: string[];
+  category: string | null;
+  metadata: Record<string, unknown>;
+  uploaded_by: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+interface AssetRow {
+  id: string;
+  name: string;
+  description: string | null;
+  type: string | null;
+  file_path: string | null;
+  file_size: number | null;
+  mime_type: string | null;
+  dimensions: string | null;
+  tags: string;
+  category: string | null;
+  metadata: string;
+  uploaded_by: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+function rowToAsset(row: AssetRow): Asset {
+  return {
+    ...row,
+    tags: JSON.parse(row.tags || "[]"),
+    metadata: JSON.parse(row.metadata || "{}"),
+  };
+}
+
+export interface CreateAssetInput {
+  name: string;
+  description?: string;
+  type?: string;
+  file_path?: string;
+  file_size?: number;
+  mime_type?: string;
+  dimensions?: string;
+  tags?: string[];
+  category?: string;
+  metadata?: Record<string, unknown>;
+  uploaded_by?: string;
+}
+
+export function createAsset(input: CreateAssetInput): Asset {
+  const db = getDatabase();
+  const id = crypto.randomUUID();
+  const tags = JSON.stringify(input.tags || []);
+  const metadata = JSON.stringify(input.metadata || {});
+
+  db.prepare(
+    `INSERT INTO assets (id, name, description, type, file_path, file_size, mime_type, dimensions, tags, category, metadata, uploaded_by)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    id,
+    input.name,
+    input.description || null,
+    input.type || null,
+    input.file_path || null,
+    input.file_size ?? null,
+    input.mime_type || null,
+    input.dimensions || null,
+    tags,
+    input.category || null,
+    metadata,
+    input.uploaded_by || null
+  );
+
+  return getAsset(id)!;
+}
+
+export function getAsset(id: string): Asset | null {
+  const db = getDatabase();
+  const row = db.prepare("SELECT * FROM assets WHERE id = ?").get(id) as AssetRow | null;
+  return row ? rowToAsset(row) : null;
+}
+
+export interface ListAssetsOptions {
+  search?: string;
+  type?: string;
+  category?: string;
+  tag?: string;
+  uploaded_by?: string;
+  limit?: number;
+  offset?: number;
+}
+
+export function listAssets(options: ListAssetsOptions = {}): Asset[] {
+  const db = getDatabase();
+  const conditions: string[] = [];
+  const params: unknown[] = [];
+
+  if (options.search) {
+    conditions.push("(name LIKE ? OR description LIKE ? OR tags LIKE ?)");
+    const q = `%${options.search}%`;
+    params.push(q, q, q);
+  }
+
+  if (options.type) {
+    conditions.push("type = ?");
+    params.push(options.type);
+  }
+
+  if (options.category) {
+    conditions.push("category = ?");
+    params.push(options.category);
+  }
+
+  if (options.tag) {
+    conditions.push("tags LIKE ?");
+    params.push(`%${options.tag}%`);
+  }
+
+  if (options.uploaded_by) {
+    conditions.push("uploaded_by = ?");
+    params.push(options.uploaded_by);
+  }
+
+  let sql = "SELECT * FROM assets";
+  if (conditions.length > 0) {
+    sql += " WHERE " + conditions.join(" AND ");
+  }
+  sql += " ORDER BY created_at DESC";
+
+  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 AssetRow[];
+  return rows.map(rowToAsset);
+}
+
+export interface UpdateAssetInput {
+  name?: string;
+  description?: string;
+  type?: string;
+  file_path?: string;
+  file_size?: number;
+  mime_type?: string;
+  dimensions?: string;
+  tags?: string[];
+  category?: string;
+  metadata?: Record<string, unknown>;
+  uploaded_by?: string;
+}
+
+export function updateAsset(id: string, input: UpdateAssetInput): Asset | null {
+  const db = getDatabase();
+  const existing = getAsset(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.file_path !== undefined) {
+    sets.push("file_path = ?");
+    params.push(input.file_path);
+  }
+  if (input.file_size !== undefined) {
+    sets.push("file_size = ?");
+    params.push(input.file_size);
+  }
+  if (input.mime_type !== undefined) {
+    sets.push("mime_type = ?");
+    params.push(input.mime_type);
+  }
+  if (input.dimensions !== undefined) {
+    sets.push("dimensions = ?");
+    params.push(input.dimensions);
+  }
+  if (input.tags !== undefined) {
+    sets.push("tags = ?");
+    params.push(JSON.stringify(input.tags));
+  }
+  if (input.category !== undefined) {
+    sets.push("category = ?");
+    params.push(input.category);
+  }
+  if (input.metadata !== undefined) {
+    sets.push("metadata = ?");
+    params.push(JSON.stringify(input.metadata));
+  }
+  if (input.uploaded_by !== undefined) {
+    sets.push("uploaded_by = ?");
+    params.push(input.uploaded_by);
+  }
+
+  if (sets.length === 0) return existing;
+
+  sets.push("updated_at = datetime('now')");
+  params.push(id);
+
+  db.prepare(
+    `UPDATE assets SET ${sets.join(", ")} WHERE id = ?`
+  ).run(...params);
+
+  return getAsset(id);
+}
+
+export function deleteAsset(id: string): boolean {
+  const db = getDatabase();
+  const result = db.prepare("DELETE FROM assets WHERE id = ?").run(id);
+  return result.changes > 0;
+}
+
+export function searchAssets(query: string): Asset[] {
+  return listAssets({ search: query });
+}
+
+export function listByType(type: string): Asset[] {
+  return listAssets({ type });
+}
+
+export function listByTag(tag: string): Asset[] {
+  return listAssets({ tag });
+}
+
+export function listByCategory(category: string): Asset[] {
+  return listAssets({ category });
+}
+
+export interface AssetStats {
+  total_assets: number;
+  total_size: number;
+  by_type: Record<string, number>;
+  by_category: Record<string, number>;
+}
+
+export function getAssetStats(): AssetStats {
+  const db = getDatabase();
+
+  const totalRow = db.prepare("SELECT COUNT(*) as count FROM assets").get() as { count: number };
+  const sizeRow = db.prepare("SELECT COALESCE(SUM(file_size), 0) as total FROM assets").get() as { total: number };
+
+  const typeRows = db.prepare(
+    "SELECT type, COUNT(*) as count FROM assets WHERE type IS NOT NULL GROUP BY type"
+  ).all() as { type: string; count: number }[];
+
+  const categoryRows = db.prepare(
+    "SELECT category, COUNT(*) as count FROM assets WHERE category IS NOT NULL GROUP BY category"
+  ).all() as { category: string; count: number }[];
+
+  const by_type: Record<string, number> = {};
+  for (const row of typeRows) {
+    by_type[row.type] = row.count;
+  }
+
+  const by_category: Record<string, number> = {};
+  for (const row of categoryRows) {
+    by_category[row.category] = row.count;
+  }
+
+  return {
+    total_assets: totalRow.count,
+    total_size: sizeRow.total,
+    by_type,
+    by_category,
+  };
+}
+
+// --- Collection types ---
+
+export interface Collection {
+  id: string;
+  name: string;
+  description: string | null;
+  created_at: string;
+}
+
+export interface CreateCollectionInput {
+  name: string;
+  description?: string;
+}
+
+export function createCollection(input: CreateCollectionInput): Collection {
+  const db = getDatabase();
+  const id = crypto.randomUUID();
+
+  db.prepare(
+    `INSERT INTO collections (id, name, description) VALUES (?, ?, ?)`
+  ).run(id, input.name, input.description || null);
+
+  return getCollection(id)!;
+}
+
+export function getCollection(id: string): Collection | null {
+  const db = getDatabase();
+  return db.prepare("SELECT * FROM collections WHERE id = ?").get(id) as Collection | null;
+}
+
+export function listCollections(): Collection[] {
+  const db = getDatabase();
+  return db.prepare("SELECT * FROM collections ORDER BY name").all() as Collection[];
+}
+
+export function deleteCollection(id: string): boolean {
+  const db = getDatabase();
+  const result = db.prepare("DELETE FROM collections WHERE id = ?").run(id);
+  return result.changes > 0;
+}
+
+// --- Collection-Asset operations ---
+
+export function addToCollection(collectionId: string, assetId: string): boolean {
+  const db = getDatabase();
+  try {
+    db.prepare(
+      "INSERT OR IGNORE INTO collection_assets (collection_id, asset_id) VALUES (?, ?)"
+    ).run(collectionId, assetId);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function removeFromCollection(collectionId: string, assetId: string): boolean {
+  const db = getDatabase();
+  const result = db.prepare(
+    "DELETE FROM collection_assets WHERE collection_id = ? AND asset_id = ?"
+  ).run(collectionId, assetId);
+  return result.changes > 0;
+}
+
+export function getCollectionAssets(collectionId: string): Asset[] {
+  const db = getDatabase();
+  const rows = db.prepare(
+    `SELECT a.* FROM assets a
+     INNER JOIN collection_assets ca ON ca.asset_id = a.id
+     WHERE ca.collection_id = ?
+     ORDER BY ca.added_at DESC`
+  ).all(collectionId) as AssetRow[];
+  return rows.map(rowToAsset);
+}

package/microservices/microservice-assets/src/db/database.ts

@@ -0,0 +1,93 @@
+/**
+ * Database connection for microservice-assets
+ */
+
+import { Database } from "bun:sqlite";
+import { existsSync, mkdirSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { MIGRATIONS } from "./migrations.js";
+
+let _db: Database | null = null;
+
+function getDbPath(): string {
+  // Environment variable override
+  if (process.env["MICROSERVICES_DIR"]) {
+    return join(process.env["MICROSERVICES_DIR"], "microservice-assets", "data.db");
+  }
+
+  // Check for .microservices in current or parent directories
+  let dir = resolve(process.cwd());
+  while (true) {
+    const candidate = join(dir, ".microservices", "microservice-assets", "data.db");
+    const msDir = join(dir, ".microservices");
+    if (existsSync(msDir)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  // Global fallback
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+  return join(home, ".microservices", "microservice-assets", "data.db");
+}
+
+function ensureDir(filePath: string): void {
+  const dir = dirname(resolve(filePath));
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+export function getDatabase(): Database {
+  if (_db) return _db;
+
+  const dbPath = getDbPath();
+  ensureDir(dbPath);
+
+  _db = new Database(dbPath);
+  _db.exec("PRAGMA journal_mode = WAL");
+  _db.exec("PRAGMA foreign_keys = ON");
+
+  // Create migrations table
+  _db.exec(`
+    CREATE TABLE IF NOT EXISTS _migrations (
+      id INTEGER PRIMARY KEY,
+      name TEXT NOT NULL,
+      applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+
+  // Apply pending migrations
+  const applied = _db
+    .query("SELECT id FROM _migrations ORDER BY id")
+    .all() as { id: number }[];
+  const appliedIds = new Set(applied.map((r) => r.id));
+
+  for (const migration of MIGRATIONS) {
+    if (appliedIds.has(migration.id)) continue;
+
+    _db.exec("BEGIN");
+    try {
+      _db.exec(migration.sql);
+      _db.prepare("INSERT INTO _migrations (id, name) VALUES (?, ?)").run(
+        migration.id,
+        migration.name
+      );
+      _db.exec("COMMIT");
+    } catch (error) {
+      _db.exec("ROLLBACK");
+      throw new Error(
+        `Migration ${migration.id} (${migration.name}) failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  return _db;
+}
+
+export function closeDatabase(): void {
+  if (_db) {
+    _db.close();
+    _db = null;
+  }
+}

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

@@ -0,0 +1,51 @@
+export interface MigrationEntry {
+  id: number;
+  name: string;
+  sql: string;
+}
+
+export const MIGRATIONS: MigrationEntry[] = [
+  {
+    id: 1,
+    name: "initial_schema",
+    sql: `
+      CREATE TABLE IF NOT EXISTS assets (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        description TEXT,
+        type TEXT CHECK(type IN ('image','video','document','audio','template','logo','font','other')),
+        file_path TEXT,
+        file_size INTEGER,
+        mime_type TEXT,
+        dimensions TEXT,
+        tags TEXT DEFAULT '[]',
+        category TEXT,
+        metadata TEXT DEFAULT '{}',
+        uploaded_by TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS collections (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        description TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS collection_assets (
+        collection_id TEXT NOT NULL REFERENCES collections(id) ON DELETE CASCADE,
+        asset_id TEXT NOT NULL REFERENCES assets(id) ON DELETE CASCADE,
+        added_at TEXT NOT NULL DEFAULT (datetime('now')),
+        PRIMARY KEY (collection_id, asset_id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_assets_name ON assets(name);
+      CREATE INDEX IF NOT EXISTS idx_assets_type ON assets(type);
+      CREATE INDEX IF NOT EXISTS idx_assets_category ON assets(category);
+      CREATE INDEX IF NOT EXISTS idx_assets_uploaded_by ON assets(uploaded_by);
+      CREATE INDEX IF NOT EXISTS idx_collections_name ON collections(name);
+      CREATE INDEX IF NOT EXISTS idx_collection_assets_asset ON collection_assets(asset_id);
+    `,
+  },
+];

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

@@ -0,0 +1,32 @@
+/**
+ * microservice-assets — Digital asset management microservice
+ */
+
+export {
+  createAsset,
+  getAsset,
+  listAssets,
+  updateAsset,
+  deleteAsset,
+  searchAssets,
+  listByType,
+  listByTag,
+  listByCategory,
+  getAssetStats,
+  createCollection,
+  getCollection,
+  listCollections,
+  deleteCollection,
+  addToCollection,
+  removeFromCollection,
+  getCollectionAssets,
+  type Asset,
+  type CreateAssetInput,
+  type UpdateAssetInput,
+  type ListAssetsOptions,
+  type AssetStats,
+  type Collection,
+  type CreateCollectionInput,
+} from "./db/assets.js";
+
+export { getDatabase, closeDatabase } from "./db/database.js";