@richardmcquiston01/online-catalog-cms 0.1.0

package/dist/index.js

@@ -0,0 +1,1527 @@
+import { readFileSync, existsSync, mkdirSync, createWriteStream, unlinkSync } from 'fs';
+import { join, resolve, extname } from 'path';
+import { fileURLToPath } from 'url';
+import { randomUUID } from 'crypto';
+import { createRequire } from 'module';
+import { pipeline } from 'stream/promises';
+
+// src/rich-text/builders.ts
+function text(content, options = {}) {
+  return { type: "text", text: content, ...options };
+}
+function link(href, children) {
+  return { type: "link", href, children };
+}
+function paragraph(children, cssClass) {
+  return { type: "paragraph", children, ...cssClass ? { cssClass } : {} };
+}
+function heading(level, children, cssClass) {
+  return {
+    type: "heading",
+    level,
+    children,
+    ...cssClass ? { cssClass } : {}
+  };
+}
+function image(src, alt, cssClass) {
+  return { type: "image", src, alt, ...cssClass ? { cssClass } : {} };
+}
+function unorderedList(items, cssClass) {
+  return {
+    type: "list",
+    ordered: false,
+    items,
+    ...cssClass ? { cssClass } : {}
+  };
+}
+function orderedList(items, cssClass) {
+  return {
+    type: "list",
+    ordered: true,
+    items,
+    ...cssClass ? { cssClass } : {}
+  };
+}
+function blockquote(children, cssClass) {
+  return {
+    type: "blockquote",
+    children,
+    ...cssClass ? { cssClass } : {}
+  };
+}
+function document(nodes) {
+  return { version: 1, nodes };
+}
+
+// src/rich-text/validate.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isInlineNode(value) {
+  if (!isObject(value)) return false;
+  if (value.type === "text") {
+    return typeof value.text === "string";
+  }
+  if (value.type === "link") {
+    return typeof value.href === "string" && Array.isArray(value.children) && value.children.every(isInlineNode);
+  }
+  return false;
+}
+function isRichTextNode(value) {
+  if (!isObject(value)) return false;
+  const type = value.type;
+  if (type === "paragraph" || type === "blockquote") {
+    return Array.isArray(value.children) && value.children.every(isInlineNode);
+  }
+  if (type === "heading") {
+    const level = value.level;
+    return typeof level === "number" && level >= 1 && level <= 6 && Array.isArray(value.children) && value.children.every(isInlineNode);
+  }
+  if (type === "image") {
+    return typeof value.src === "string" && typeof value.alt === "string";
+  }
+  if (type === "list") {
+    return typeof value.ordered === "boolean" && Array.isArray(value.items) && value.items.every(
+      (item) => Array.isArray(item) && item.every(isInlineNode)
+    );
+  }
+  return false;
+}
+function isRichTextDocument(value) {
+  if (!isObject(value)) return false;
+  if (value.version !== 1) return false;
+  if (!Array.isArray(value.nodes)) return false;
+  return value.nodes.every(isRichTextNode);
+}
+function assertRichTextDocument(value) {
+  if (!isRichTextDocument(value)) {
+    throw new TypeError(
+      "Invalid RichTextDocument: must be { version: 1, nodes: RichTextNode[] }"
+    );
+  }
+}
+
+// src/installer/Installer.ts
+var Installer = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  adapter;
+  /**
+   * Run database migrations and verify the resulting schema.
+   * @returns The verification result after migration.
+   */
+  async install(options = {}) {
+    if (options.dryRun) {
+      return this.adapter.verify();
+    }
+    await this.adapter.initialize();
+    return this.adapter.verify();
+  }
+  /** Check that the schema is correct without running migrations. */
+  async verify() {
+    return this.adapter.verify();
+  }
+};
+
+// src/services/CategoryService.ts
+var CategoryService = class {
+  constructor(repo) {
+    this.repo = repo;
+  }
+  repo;
+  async create(input) {
+    return this.repo.create(input);
+  }
+  async get(id) {
+    return this.repo.get(id);
+  }
+  async update(id, input) {
+    return this.repo.update(id, input);
+  }
+  async delete(id) {
+    return this.repo.delete(id);
+  }
+  async list(filter) {
+    return this.repo.list(filter);
+  }
+};
+
+// src/services/ImageService.ts
+var ImageService = class {
+  constructor(repo, storage) {
+    this.repo = repo;
+    this.storage = storage;
+  }
+  repo;
+  storage;
+  /**
+   * Upload a file via the storage adapter and create an image record.
+   * Requires a storage adapter to be configured.
+   */
+  async upload(input) {
+    if (!this.storage) {
+      throw new Error(
+        "A storage adapter must be configured on OnlineCatalog to upload images."
+      );
+    }
+    const url = await this.storage.upload(input.file, input.filename, {
+      contentType: input.contentType
+    });
+    return this.repo.create({
+      productId: input.productId,
+      url,
+      altText: input.altText,
+      sortOrder: input.sortOrder
+    });
+  }
+  /** Associate an already-hosted image URL with a product. */
+  async addUrl(input) {
+    return this.repo.create(input);
+  }
+  async get(id) {
+    return this.repo.get(id);
+  }
+  async delete(id) {
+    const image2 = await this.repo.get(id);
+    if (!image2) return;
+    if (this.storage) {
+      await this.storage.delete(image2.url).catch(() => {
+      });
+    }
+    await this.repo.delete(id);
+  }
+  async listByProduct(productId) {
+    return this.repo.listByProduct(productId);
+  }
+};
+
+// src/services/ProductService.ts
+var ProductService = class {
+  constructor(repo, storage) {
+    this.repo = repo;
+    this.storage = storage;
+  }
+  repo;
+  storage;
+  async create(input) {
+    return this.repo.create(input);
+  }
+  async get(id) {
+    return this.repo.get(id);
+  }
+  async update(id, input) {
+    return this.repo.update(id, input);
+  }
+  async delete(id) {
+    const product = await this.repo.get(id);
+    if (!product) return;
+    if (this.storage) {
+      for (const image2 of product.images) {
+        await this.storage.delete(image2.url).catch(() => {
+        });
+      }
+    }
+    await this.repo.delete(id);
+  }
+  async list(filter) {
+    return this.repo.list(filter);
+  }
+};
+
+// src/catalog.ts
+var OnlineCatalog = class {
+  products;
+  categories;
+  images;
+  installer;
+  db;
+  constructor(config) {
+    this.db = config.db;
+    this.products = new ProductService(config.db.products, config.storage);
+    this.categories = new CategoryService(config.db.categories);
+    this.images = new ImageService(config.db.images, config.storage);
+    this.installer = new Installer(config.db);
+  }
+  /**
+   * Initialize the catalog. Runs database migrations on first use.
+   * Must be called before any other method.
+   */
+  async initialize() {
+    await this.db.initialize();
+  }
+  /** Release all resources held by the database adapter. */
+  async close() {
+    await this.db.close();
+  }
+};
+
+// src/adapters/database/relational/BaseSQLAdapter.ts
+var REQUIRED_TABLES = [
+  "occ_category",
+  "occ_product",
+  "occ_image",
+  "occ_migration"
+];
+var BaseSQLAdapter = class {
+  async initialize() {
+    const migration = this.migrationSql;
+    const statements = migration.split(";").map((s) => s.trim()).filter((s) => s.length > 0);
+    for (const stmt of statements) {
+      await this.db.run(stmt);
+    }
+  }
+  async verify() {
+    const issues = [];
+    for (const table of REQUIRED_TABLES) {
+      const row = await this.db.get(
+        this.tableExistsQuery(table)
+      );
+      if (!row) {
+        issues.push(`Missing table: ${table}`);
+      }
+    }
+    return { ok: issues.length === 0, issues };
+  }
+};
+
+// src/utils/slug.ts
+function generateSlug(value) {
+  return value.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+
+// src/adapters/database/relational/rowMappers.ts
+function toDate(value) {
+  return value instanceof Date ? value : new Date(value);
+}
+function productFromRow(row, images) {
+  return {
+    id: row.id,
+    name: row.name,
+    slug: row.slug,
+    description: JSON.parse(row.description),
+    price: row.price,
+    sku: row.sku,
+    categoryId: row.category_id,
+    images,
+    metadata: JSON.parse(row.metadata),
+    createdAt: toDate(row.created_at),
+    updatedAt: toDate(row.updated_at)
+  };
+}
+function categoryFromRow(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    slug: row.slug,
+    parentId: row.parent_id,
+    metadata: JSON.parse(row.metadata),
+    createdAt: toDate(row.created_at),
+    updatedAt: toDate(row.updated_at)
+  };
+}
+function imageFromRow(row) {
+  return {
+    id: row.id,
+    productId: row.product_id,
+    url: row.url,
+    altText: row.alt_text,
+    sortOrder: row.sort_order,
+    createdAt: toDate(row.created_at)
+  };
+}
+
+// src/adapters/database/relational/SQLCategoryRepository.ts
+var SQLCategoryRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  async create(input) {
+    const id = randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const slug = input.slug ?? generateSlug(input.name);
+    await this.db.run(
+      `INSERT INTO occ_category (id, name, slug, parent_id, metadata, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      [
+        id,
+        input.name,
+        slug,
+        input.parentId ?? null,
+        JSON.stringify(input.metadata ?? {}),
+        now,
+        now
+      ]
+    );
+    const category = await this.get(id);
+    if (!category)
+      throw new Error(`Failed to fetch category after insert: ${id}`);
+    return category;
+  }
+  async get(id) {
+    const row = await this.db.get(
+      "SELECT * FROM occ_category WHERE id = ?",
+      [id]
+    );
+    return row ? categoryFromRow(row) : null;
+  }
+  async update(id, input) {
+    const existing = await this.get(id);
+    if (!existing) throw new Error(`Category not found: ${id}`);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await this.db.run(
+      `UPDATE occ_category SET
+         name       = ?,
+         slug       = ?,
+         parent_id  = ?,
+         metadata   = ?,
+         updated_at = ?
+       WHERE id = ?`,
+      [
+        input.name ?? existing.name,
+        input.slug ?? existing.slug,
+        input.parentId !== void 0 ? input.parentId : existing.parentId,
+        JSON.stringify(input.metadata ?? existing.metadata),
+        now,
+        id
+      ]
+    );
+    const updated = await this.get(id);
+    if (!updated)
+      throw new Error(`Failed to fetch category after update: ${id}`);
+    return updated;
+  }
+  async delete(id) {
+    await this.db.run("DELETE FROM occ_category WHERE id = ?", [id]);
+  }
+  async list(filter = {}) {
+    const conditions = [];
+    const params = [];
+    if (filter.parentId !== void 0) {
+      if (filter.parentId === null) {
+        conditions.push("parent_id IS NULL");
+      } else {
+        conditions.push("parent_id = ?");
+        params.push(filter.parentId);
+      }
+    }
+    if (filter.search) {
+      conditions.push("name LIKE ?");
+      params.push(`%${filter.search}%`);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const limit = filter.limit !== void 0 ? `LIMIT ${filter.limit}` : "";
+    const offset = filter.offset !== void 0 ? `OFFSET ${filter.offset}` : "";
+    const rows = await this.db.all(
+      `SELECT * FROM occ_category ${where} ORDER BY name ASC ${limit} ${offset}`,
+      params
+    );
+    return rows.map(categoryFromRow);
+  }
+};
+var SQLImageRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  async create(input) {
+    const id = randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const sortOrder = input.sortOrder ?? 0;
+    await this.db.run(
+      `INSERT INTO occ_image (id, product_id, url, alt_text, sort_order, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`,
+      [id, input.productId, input.url, input.altText, sortOrder, now]
+    );
+    const image2 = await this.get(id);
+    if (!image2) throw new Error(`Failed to fetch image after insert: ${id}`);
+    return image2;
+  }
+  async get(id) {
+    const row = await this.db.get(
+      "SELECT * FROM occ_image WHERE id = ?",
+      [id]
+    );
+    return row ? imageFromRow(row) : null;
+  }
+  async delete(id) {
+    await this.db.run("DELETE FROM occ_image WHERE id = ?", [id]);
+  }
+  async listByProduct(productId) {
+    const rows = await this.db.all(
+      "SELECT * FROM occ_image WHERE product_id = ? ORDER BY sort_order ASC",
+      [productId]
+    );
+    return rows.map(imageFromRow);
+  }
+};
+var SQLProductRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  async create(input) {
+    const id = randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const slug = input.slug ?? generateSlug(input.name);
+    await this.db.run(
+      `INSERT INTO occ_product
+         (id, name, slug, description, price, sku, category_id, metadata, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        id,
+        input.name,
+        slug,
+        JSON.stringify(input.description),
+        input.price,
+        input.sku ?? null,
+        input.categoryId ?? null,
+        JSON.stringify(input.metadata ?? {}),
+        now,
+        now
+      ]
+    );
+    const product = await this.get(id);
+    if (!product)
+      throw new Error(`Failed to fetch product after insert: ${id}`);
+    return product;
+  }
+  async get(id) {
+    const row = await this.db.get(
+      "SELECT * FROM occ_product WHERE id = ?",
+      [id]
+    );
+    if (!row) return null;
+    const imageRows = await this.db.all(
+      "SELECT * FROM occ_image WHERE product_id = ? ORDER BY sort_order ASC",
+      [id]
+    );
+    return productFromRow(row, imageRows.map(imageFromRow));
+  }
+  async update(id, input) {
+    const existing = await this.get(id);
+    if (!existing) throw new Error(`Product not found: ${id}`);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await this.db.run(
+      `UPDATE occ_product SET
+         name        = ?,
+         slug        = ?,
+         description = ?,
+         price       = ?,
+         sku         = ?,
+         category_id = ?,
+         metadata    = ?,
+         updated_at  = ?
+       WHERE id = ?`,
+      [
+        input.name ?? existing.name,
+        input.slug ?? existing.slug,
+        JSON.stringify(input.description ?? existing.description),
+        input.price ?? existing.price,
+        input.sku !== void 0 ? input.sku : existing.sku,
+        input.categoryId !== void 0 ? input.categoryId : existing.categoryId,
+        JSON.stringify(input.metadata ?? existing.metadata),
+        now,
+        id
+      ]
+    );
+    const updated = await this.get(id);
+    if (!updated)
+      throw new Error(`Failed to fetch product after update: ${id}`);
+    return updated;
+  }
+  async delete(id) {
+    await this.db.run("DELETE FROM occ_product WHERE id = ?", [id]);
+  }
+  async list(filter = {}) {
+    const conditions = [];
+    const params = [];
+    if (filter.categoryId !== void 0) {
+      conditions.push("category_id = ?");
+      params.push(filter.categoryId);
+    }
+    if (filter.search) {
+      conditions.push("(name LIKE ? OR sku LIKE ?)");
+      params.push(`%${filter.search}%`, `%${filter.search}%`);
+    }
+    if (filter.minPrice !== void 0) {
+      conditions.push("price >= ?");
+      params.push(filter.minPrice);
+    }
+    if (filter.maxPrice !== void 0) {
+      conditions.push("price <= ?");
+      params.push(filter.maxPrice);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const limit = filter.limit !== void 0 ? `LIMIT ${filter.limit}` : "";
+    const offset = filter.offset !== void 0 ? `OFFSET ${filter.offset}` : "";
+    const rows = await this.db.all(
+      `SELECT * FROM occ_product ${where} ORDER BY created_at DESC ${limit} ${offset}`,
+      params
+    );
+    const products = [];
+    for (const row of rows) {
+      const imageRows = await this.db.all(
+        "SELECT * FROM occ_image WHERE product_id = ? ORDER BY sort_order ASC",
+        [row.id]
+      );
+      products.push(productFromRow(row, imageRows.map(imageFromRow)));
+    }
+    return products;
+  }
+};
+
+// src/adapters/database/sqlite/SQLiteAdapter.ts
+var BunSQLiteRunner = class {
+  // biome-ignore lint/suspicious/noExplicitAny: bun:sqlite Database type
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  async run(sql, params = []) {
+    this.db.run(sql, params);
+  }
+  async all(sql, params = []) {
+    return this.db.query(sql).all(...params);
+  }
+  async get(sql, params = []) {
+    return this.db.query(sql).get(...params);
+  }
+};
+var BetterSqliteRunner = class {
+  // biome-ignore lint/suspicious/noExplicitAny: better-sqlite3 Database type
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  async run(sql, params = []) {
+    this.db.prepare(sql).run(...params);
+  }
+  async all(sql, params = []) {
+    return this.db.prepare(sql).all(...params);
+  }
+  async get(sql, params = []) {
+    return this.db.prepare(sql).get(...params);
+  }
+};
+async function createSQLiteInstance(filename) {
+  try {
+    const { Database } = await import('bun:sqlite');
+    const db = new Database(filename);
+    db.exec("PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON;");
+    return {
+      runner: new BunSQLiteRunner(db),
+      instance: db,
+      close: () => db.close()
+    };
+  } catch {
+  }
+  try {
+    const { createRequire: createRequire6 } = await import('module');
+    const require2 = createRequire6(import.meta.url);
+    const Database = require2("better-sqlite3");
+    const db = new Database(filename);
+    db.pragma("journal_mode = WAL");
+    db.pragma("foreign_keys = ON");
+    return {
+      runner: new BetterSqliteRunner(db),
+      instance: db,
+      close: () => db.close()
+    };
+  } catch {
+    throw new Error(
+      "No SQLite driver found. In Bun environments, bun:sqlite is built-in. In Node.js environments, run: bun add better-sqlite3"
+    );
+  }
+}
+var __dirname$1 = fileURLToPath(new URL(".", import.meta.url));
+var MIGRATION_PATH = join(
+  __dirname$1,
+  "../relational/migrations/001_initial.sql"
+);
+var SQLiteAdapter = class extends BaseSQLAdapter {
+  runner;
+  closeHandle;
+  config;
+  _products;
+  _categories;
+  _images;
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  get db() {
+    if (!this.runner) throw new Error("Call initialize() first");
+    return this.runner;
+  }
+  get products() {
+    if (!this._products) throw new Error("Call initialize() first");
+    return this._products;
+  }
+  get categories() {
+    if (!this._categories) throw new Error("Call initialize() first");
+    return this._categories;
+  }
+  get images() {
+    if (!this._images) throw new Error("Call initialize() first");
+    return this._images;
+  }
+  /** Must be called before any other method. Sets up the SQLite driver. */
+  async initialize() {
+    const { runner, close } = await createSQLiteInstance(this.config.filename);
+    this.runner = runner;
+    this._products = new SQLProductRepository(runner);
+    this._categories = new SQLCategoryRepository(runner);
+    this._images = new SQLImageRepository(runner);
+    this.closeHandle = close;
+    await super.initialize();
+  }
+  get migrationSql() {
+    return readFileSync(MIGRATION_PATH, "utf8");
+  }
+  tableExistsQuery(table) {
+    return `SELECT name FROM sqlite_master WHERE type='table' AND name='${table}'`;
+  }
+  async verify() {
+    return super.verify();
+  }
+  async close() {
+    this.closeHandle?.();
+  }
+};
+function loadDriver() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    const mod = require2("postgres");
+    return mod.default ?? mod;
+  } catch {
+    throw new Error("postgres is not installed. Run: bun add postgres");
+  }
+}
+var PostgresSQLRunner = class {
+  constructor(sql) {
+    this.sql = sql;
+  }
+  sql;
+  async run(query, params = []) {
+    await this.sql.unsafe(query, params);
+  }
+  async all(query, params = []) {
+    const rows = await this.sql.unsafe(query, params);
+    return rows;
+  }
+  async get(query, params = []) {
+    const rows = await this.sql.unsafe(query, params);
+    return rows[0];
+  }
+};
+var __dirname2 = fileURLToPath(new URL(".", import.meta.url));
+var MIGRATION_PATH2 = join(
+  __dirname2,
+  "../relational/migrations/001_initial.sql"
+);
+var PostgresAdapter = class extends BaseSQLAdapter {
+  db;
+  products;
+  categories;
+  images;
+  sql;
+  constructor(config) {
+    super();
+    const connect = loadDriver();
+    this.sql = connect(config.url);
+    const runner = new PostgresSQLRunner(this.sql);
+    this.db = runner;
+    this.products = new SQLProductRepository(runner);
+    this.categories = new SQLCategoryRepository(runner);
+    this.images = new SQLImageRepository(runner);
+  }
+  get migrationSql() {
+    return readFileSync(MIGRATION_PATH2, "utf8");
+  }
+  tableExistsQuery(table) {
+    return `SELECT table_name AS name FROM information_schema.tables WHERE table_schema = 'public' AND table_name = '${table}'`;
+  }
+  async verify() {
+    return super.verify();
+  }
+  async close() {
+    await this.sql.end();
+  }
+};
+function loadDriver2() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    return require2("mysql2/promise");
+  } catch {
+    throw new Error("mysql2 is not installed. Run: bun add mysql2");
+  }
+}
+var MySQLSQLRunner = class {
+  constructor(pool) {
+    this.pool = pool;
+  }
+  pool;
+  // mysql2 types require `ExecuteValues` (any[]), so we cast here.
+  async run(query, params = []) {
+    await this.pool.execute(query, params);
+  }
+  async all(query, params = []) {
+    const [rows] = await this.pool.execute(query, params);
+    return rows;
+  }
+  async get(query, params = []) {
+    const [rows] = await this.pool.execute(query, params);
+    return rows[0];
+  }
+};
+var __dirname3 = fileURLToPath(new URL(".", import.meta.url));
+var MIGRATION_PATH3 = join(
+  __dirname3,
+  "../relational/migrations/001_initial.sql"
+);
+var MySQLAdapter = class extends BaseSQLAdapter {
+  db;
+  products;
+  categories;
+  images;
+  pool;
+  constructor(config) {
+    super();
+    const { createPool } = loadDriver2();
+    this.pool = createPool(config);
+    const runner = new MySQLSQLRunner(this.pool);
+    this.db = runner;
+    this.products = new SQLProductRepository(runner);
+    this.categories = new SQLCategoryRepository(runner);
+    this.images = new SQLImageRepository(runner);
+  }
+  get migrationSql() {
+    return readFileSync(MIGRATION_PATH3, "utf8").replace(
+      /ON CONFLICT \(version\) DO NOTHING/g,
+      ""
+    );
+  }
+  tableExistsQuery(table) {
+    return `SELECT table_name AS name FROM information_schema.tables WHERE table_schema = DATABASE() AND table_name = '${table}'`;
+  }
+  async verify() {
+    return super.verify();
+  }
+  async close() {
+    await this.pool.end();
+  }
+};
+function loadDriver3() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    const mod = require2("ioredis");
+    return mod.default ?? mod;
+  } catch {
+    throw new Error("ioredis is not installed. Run: bun add ioredis");
+  }
+}
+var RedisAdapter = class {
+  client;
+  prefix;
+  products;
+  categories;
+  images;
+  constructor(config) {
+    const RedisClass = loadDriver3();
+    this.client = new RedisClass(config.url);
+    this.prefix = config.keyPrefix ?? "occ";
+    this.products = new RedisProductRepository(this.client, this.prefix);
+    this.categories = new RedisCategoryRepository(this.client, this.prefix);
+    this.images = new RedisImageRepository(this.client, this.prefix);
+  }
+  async initialize() {
+    await this.client.ping();
+  }
+  async verify() {
+    try {
+      await this.client.ping();
+      return { ok: true, issues: [] };
+    } catch (err) {
+      return {
+        ok: false,
+        issues: [`Redis connection failed: ${String(err)}`]
+      };
+    }
+  }
+  async close() {
+    await this.client.quit();
+  }
+};
+var RedisProductRepository = class {
+  constructor(client, prefix) {
+    this.client = client;
+    this.prefix = prefix;
+  }
+  client;
+  prefix;
+  key(id) {
+    return `${this.prefix}:product:${id}`;
+  }
+  async create(input) {
+    const id = randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const product = {
+      id,
+      name: input.name,
+      slug: input.slug ?? generateSlug(input.name),
+      description: input.description,
+      price: input.price,
+      sku: input.sku ?? null,
+      categoryId: input.categoryId ?? null,
+      images: [],
+      metadata: input.metadata ?? {},
+      createdAt: new Date(now),
+      updatedAt: new Date(now)
+    };
+    await this.client.set(this.key(id), JSON.stringify(product));
+    await this.client.sadd(`${this.prefix}:products:all`, id);
+    if (product.categoryId) {
+      await this.client.sadd(
+        `${this.prefix}:products:cat:${product.categoryId}`,
+        id
+      );
+    }
+    return product;
+  }
+  async get(id) {
+    const raw = await this.client.get(this.key(id));
+    if (!raw) return null;
+    const product = JSON.parse(raw);
+    product.createdAt = new Date(product.createdAt);
+    product.updatedAt = new Date(product.updatedAt);
+    return product;
+  }
+  async update(id, input) {
+    const existing = await this.get(id);
+    if (!existing) throw new Error(`Product not found: ${id}`);
+    const oldCategoryId = existing.categoryId;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const updated = {
+      ...existing,
+      name: input.name ?? existing.name,
+      slug: input.slug ?? existing.slug,
+      description: input.description ?? existing.description,
+      price: input.price ?? existing.price,
+      sku: input.sku !== void 0 ? input.sku : existing.sku,
+      categoryId: input.categoryId !== void 0 ? input.categoryId : existing.categoryId,
+      metadata: input.metadata ?? existing.metadata,
+      updatedAt: new Date(now)
+    };
+    await this.client.set(this.key(id), JSON.stringify(updated));
+    if (oldCategoryId !== updated.categoryId) {
+      if (oldCategoryId) {
+        await this.client.srem(
+          `${this.prefix}:products:cat:${oldCategoryId}`,
+          id
+        );
+      }
+      if (updated.categoryId) {
+        await this.client.sadd(
+          `${this.prefix}:products:cat:${updated.categoryId}`,
+          id
+        );
+      }
+    }
+    return updated;
+  }
+  async delete(id) {
+    const existing = await this.get(id);
+    await this.client.del(this.key(id));
+    await this.client.srem(`${this.prefix}:products:all`, id);
+    if (existing?.categoryId) {
+      await this.client.srem(
+        `${this.prefix}:products:cat:${existing.categoryId}`,
+        id
+      );
+    }
+  }
+  async list(filter = {}) {
+    let ids;
+    if (filter.categoryId !== void 0) {
+      ids = await this.client.smembers(
+        `${this.prefix}:products:cat:${filter.categoryId}`
+      );
+    } else {
+      ids = await this.client.smembers(`${this.prefix}:products:all`);
+    }
+    const products = [];
+    for (const id of ids) {
+      const product = await this.get(id);
+      if (!product) continue;
+      if (filter.search && !product.name.toLowerCase().includes(filter.search.toLowerCase()))
+        continue;
+      if (filter.minPrice !== void 0 && product.price < filter.minPrice)
+        continue;
+      if (filter.maxPrice !== void 0 && product.price > filter.maxPrice)
+        continue;
+      products.push(product);
+    }
+    products.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    const start = filter.offset ?? 0;
+    const end = filter.limit !== void 0 ? start + filter.limit : void 0;
+    return products.slice(start, end);
+  }
+};
+var RedisCategoryRepository = class {
+  constructor(client, prefix) {
+    this.client = client;
+    this.prefix = prefix;
+  }
+  client;
+  prefix;
+  key(id) {
+    return `${this.prefix}:category:${id}`;
+  }
+  async create(input) {
+    const id = randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const category = {
+      id,
+      name: input.name,
+      slug: input.slug ?? generateSlug(input.name),
+      parentId: input.parentId ?? null,
+      metadata: input.metadata ?? {},
+      createdAt: new Date(now),
+      updatedAt: new Date(now)
+    };
+    await this.client.set(this.key(id), JSON.stringify(category));
+    await this.client.sadd(`${this.prefix}:categories:all`, id);
+    return category;
+  }
+  async get(id) {
+    const raw = await this.client.get(this.key(id));
+    if (!raw) return null;
+    const category = JSON.parse(raw);
+    category.createdAt = new Date(category.createdAt);
+    category.updatedAt = new Date(category.updatedAt);
+    return category;
+  }
+  async update(id, input) {
+    const existing = await this.get(id);
+    if (!existing) throw new Error(`Category not found: ${id}`);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const updated = {
+      ...existing,
+      name: input.name ?? existing.name,
+      slug: input.slug ?? existing.slug,
+      parentId: input.parentId !== void 0 ? input.parentId : existing.parentId,
+      metadata: input.metadata ?? existing.metadata,
+      updatedAt: new Date(now)
+    };
+    await this.client.set(this.key(id), JSON.stringify(updated));
+    return updated;
+  }
+  async delete(id) {
+    await this.client.del(this.key(id));
+    await this.client.srem(`${this.prefix}:categories:all`, id);
+  }
+  async list(filter = {}) {
+    const ids = await this.client.smembers(`${this.prefix}:categories:all`);
+    const categories = [];
+    for (const id of ids) {
+      const category = await this.get(id);
+      if (!category) continue;
+      if (filter.parentId !== void 0) {
+        if (category.parentId !== filter.parentId) continue;
+      }
+      if (filter.search && !category.name.toLowerCase().includes(filter.search.toLowerCase()))
+        continue;
+      categories.push(category);
+    }
+    categories.sort((a, b) => a.name.localeCompare(b.name));
+    const start = filter.offset ?? 0;
+    const end = filter.limit !== void 0 ? start + filter.limit : void 0;
+    return categories.slice(start, end);
+  }
+};
+var RedisImageRepository = class {
+  constructor(client, prefix) {
+    this.client = client;
+    this.prefix = prefix;
+  }
+  client;
+  prefix;
+  key(id) {
+    return `${this.prefix}:image:${id}`;
+  }
+  async create(input) {
+    const id = randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const image2 = {
+      id,
+      productId: input.productId,
+      url: input.url,
+      altText: input.altText,
+      sortOrder: input.sortOrder ?? 0,
+      createdAt: new Date(now)
+    };
+    await this.client.set(this.key(id), JSON.stringify(image2));
+    await this.client.zadd(
+      `${this.prefix}:images:product:${input.productId}`,
+      image2.sortOrder,
+      id
+    );
+    return image2;
+  }
+  async get(id) {
+    const raw = await this.client.get(this.key(id));
+    if (!raw) return null;
+    const image2 = JSON.parse(raw);
+    image2.createdAt = new Date(image2.createdAt);
+    return image2;
+  }
+  async delete(id) {
+    const image2 = await this.get(id);
+    await this.client.del(this.key(id));
+    if (image2) {
+      await this.client.zrem(
+        `${this.prefix}:images:product:${image2.productId}`,
+        id
+      );
+    }
+  }
+  async listByProduct(productId) {
+    const ids = await this.client.zrange(
+      `${this.prefix}:images:product:${productId}`,
+      0,
+      -1
+    );
+    const images = [];
+    for (const id of ids) {
+      const image2 = await this.get(id);
+      if (image2) images.push(image2);
+    }
+    return images;
+  }
+};
+function loadDriver4() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    const { MongoClient } = require2("mongodb");
+    return MongoClient;
+  } catch {
+    throw new Error("mongodb is not installed. Run: bun add mongodb");
+  }
+}
+var MongoDBAdapter = class {
+  client;
+  dbName;
+  products;
+  categories;
+  images;
+  constructor(config) {
+    const MongoClient = loadDriver4();
+    this.client = new MongoClient(config.url);
+    this.dbName = config.database ?? "online_catalog";
+    const db = () => this.client.db(this.dbName);
+    this.products = new MongoProductRepository(db);
+    this.categories = new MongoCategoryRepository(db);
+    this.images = new MongoImageRepository(db);
+  }
+  async initialize() {
+    await this.client.connect();
+    const db = this.client.db(this.dbName);
+    await db.collection("occ_product").createIndex({ slug: 1 }, { unique: true });
+    await db.collection("occ_product").createIndex({ categoryId: 1 });
+    await db.collection("occ_category").createIndex({ slug: 1 }, { unique: true });
+    await db.collection("occ_image").createIndex({ productId: 1, sortOrder: 1 });
+  }
+  async verify() {
+    try {
+      await this.client.db(this.dbName).command({ ping: 1 });
+      return { ok: true, issues: [] };
+    } catch (err) {
+      return {
+        ok: false,
+        issues: [`MongoDB connection failed: ${String(err)}`]
+      };
+    }
+  }
+  async close() {
+    await this.client.close();
+  }
+};
+var MongoProductRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  col() {
+    return this.db().collection("occ_product");
+  }
+  imgCol() {
+    return this.db().collection("occ_image");
+  }
+  async toProduct(doc) {
+    const images = await this.imgCol().find({ productId: doc._id }).sort({ sortOrder: 1 }).toArray();
+    return {
+      id: doc._id,
+      name: doc.name,
+      slug: doc.slug,
+      description: doc.description,
+      price: doc.price,
+      sku: doc.sku,
+      categoryId: doc.categoryId,
+      images: images.map((img) => ({
+        id: img._id,
+        productId: img.productId,
+        url: img.url,
+        altText: img.altText,
+        sortOrder: img.sortOrder,
+        createdAt: img.createdAt
+      })),
+      metadata: doc.metadata,
+      createdAt: doc.createdAt,
+      updatedAt: doc.updatedAt
+    };
+  }
+  async create(input) {
+    const id = randomUUID();
+    const now = /* @__PURE__ */ new Date();
+    const doc = {
+      _id: id,
+      name: input.name,
+      slug: input.slug ?? generateSlug(input.name),
+      description: input.description,
+      price: input.price,
+      sku: input.sku ?? null,
+      categoryId: input.categoryId ?? null,
+      metadata: input.metadata ?? {},
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.col().insertOne(doc);
+    return this.toProduct(doc);
+  }
+  async get(id) {
+    const doc = await this.col().findOne({ _id: id });
+    if (!doc) return null;
+    return this.toProduct(doc);
+  }
+  async update(id, input) {
+    const existing = await this.get(id);
+    if (!existing) throw new Error(`Product not found: ${id}`);
+    const now = /* @__PURE__ */ new Date();
+    await this.col().updateOne(
+      { _id: id },
+      {
+        $set: {
+          name: input.name ?? existing.name,
+          slug: input.slug ?? existing.slug,
+          description: input.description ?? existing.description,
+          price: input.price ?? existing.price,
+          sku: input.sku !== void 0 ? input.sku : existing.sku,
+          categoryId: input.categoryId !== void 0 ? input.categoryId : existing.categoryId,
+          metadata: input.metadata ?? existing.metadata,
+          updatedAt: now
+        }
+      }
+    );
+    const updated = await this.get(id);
+    if (!updated)
+      throw new Error(`Failed to fetch product after update: ${id}`);
+    return updated;
+  }
+  async delete(id) {
+    await this.col().deleteOne({ _id: id });
+  }
+  async list(filter = {}) {
+    const query = {};
+    if (filter.categoryId !== void 0) query.categoryId = filter.categoryId;
+    if (filter.minPrice !== void 0 || filter.maxPrice !== void 0) {
+      query.price = {};
+      if (filter.minPrice !== void 0) query.price.$gte = filter.minPrice;
+      if (filter.maxPrice !== void 0) query.price.$lte = filter.maxPrice;
+    }
+    if (filter.search) {
+      query.$or = [
+        { name: { $regex: filter.search, $options: "i" } },
+        { sku: { $regex: filter.search, $options: "i" } }
+      ];
+    }
+    let cursor = this.col().find(query).sort({ createdAt: -1 });
+    if (filter.offset) cursor = cursor.skip(filter.offset);
+    if (filter.limit) cursor = cursor.limit(filter.limit);
+    const docs = await cursor.toArray();
+    return Promise.all(docs.map((doc) => this.toProduct(doc)));
+  }
+};
+var MongoCategoryRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  col() {
+    return this.db().collection("occ_category");
+  }
+  toCategory(doc) {
+    return {
+      id: doc._id,
+      name: doc.name,
+      slug: doc.slug,
+      parentId: doc.parentId,
+      metadata: doc.metadata,
+      createdAt: doc.createdAt,
+      updatedAt: doc.updatedAt
+    };
+  }
+  async create(input) {
+    const id = randomUUID();
+    const now = /* @__PURE__ */ new Date();
+    const doc = {
+      _id: id,
+      name: input.name,
+      slug: input.slug ?? generateSlug(input.name),
+      parentId: input.parentId ?? null,
+      metadata: input.metadata ?? {},
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.col().insertOne(doc);
+    return this.toCategory(doc);
+  }
+  async get(id) {
+    const doc = await this.col().findOne({ _id: id });
+    return doc ? this.toCategory(doc) : null;
+  }
+  async update(id, input) {
+    const existing = await this.get(id);
+    if (!existing) throw new Error(`Category not found: ${id}`);
+    const now = /* @__PURE__ */ new Date();
+    await this.col().updateOne(
+      { _id: id },
+      {
+        $set: {
+          name: input.name ?? existing.name,
+          slug: input.slug ?? existing.slug,
+          parentId: input.parentId !== void 0 ? input.parentId : existing.parentId,
+          metadata: input.metadata ?? existing.metadata,
+          updatedAt: now
+        }
+      }
+    );
+    const updated = await this.get(id);
+    if (!updated)
+      throw new Error(`Failed to fetch category after update: ${id}`);
+    return updated;
+  }
+  async delete(id) {
+    await this.col().deleteOne({ _id: id });
+  }
+  async list(filter = {}) {
+    const query = {};
+    if (filter.parentId !== void 0) query.parentId = filter.parentId;
+    if (filter.search) {
+      query.name = { $regex: filter.search, $options: "i" };
+    }
+    let cursor = this.col().find(query).sort({ name: 1 });
+    if (filter.offset) cursor = cursor.skip(filter.offset);
+    if (filter.limit) cursor = cursor.limit(filter.limit);
+    const docs = await cursor.toArray();
+    return docs.map((doc) => this.toCategory(doc));
+  }
+};
+var MongoImageRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  col() {
+    return this.db().collection("occ_image");
+  }
+  async create(input) {
+    const id = randomUUID();
+    const now = /* @__PURE__ */ new Date();
+    const doc = {
+      _id: id,
+      productId: input.productId,
+      url: input.url,
+      altText: input.altText,
+      sortOrder: input.sortOrder ?? 0,
+      createdAt: now
+    };
+    await this.col().insertOne(doc);
+    return {
+      id: doc._id,
+      productId: doc.productId,
+      url: doc.url,
+      altText: doc.altText,
+      sortOrder: doc.sortOrder,
+      createdAt: doc.createdAt
+    };
+  }
+  async get(id) {
+    const doc = await this.col().findOne({ _id: id });
+    if (!doc) return null;
+    return {
+      id: doc._id,
+      productId: doc.productId,
+      url: doc.url,
+      altText: doc.altText,
+      sortOrder: doc.sortOrder,
+      createdAt: doc.createdAt
+    };
+  }
+  async delete(id) {
+    await this.col().deleteOne({ _id: id });
+  }
+  async listByProduct(productId) {
+    const docs = await this.col().find({ productId }).sort({ sortOrder: 1 }).toArray();
+    return docs.map((doc) => ({
+      id: doc._id,
+      productId: doc.productId,
+      url: doc.url,
+      altText: doc.altText,
+      sortOrder: doc.sortOrder,
+      createdAt: doc.createdAt
+    }));
+  }
+};
+var LocalStorageAdapter = class {
+  uploadDir;
+  baseUrl;
+  constructor(config) {
+    this.uploadDir = resolve(config.uploadDir);
+    this.baseUrl = config.baseUrl ?? "/uploads";
+    if (!existsSync(this.uploadDir)) {
+      mkdirSync(this.uploadDir, { recursive: true });
+    }
+  }
+  async upload(file, filename, _options) {
+    const safeName = filename.replace(/[^a-zA-Z0-9._-]/g, "_");
+    const uniqueName = `${Date.now()}-${safeName}`;
+    const filePath = join(this.uploadDir, uniqueName);
+    if (Buffer.isBuffer(file)) {
+      await Bun.write(filePath, file);
+    } else {
+      const writeStream = createWriteStream(filePath);
+      await pipeline(file, writeStream);
+    }
+    return this.getPublicUrl(uniqueName);
+  }
+  async delete(url) {
+    const key = this.urlToKey(url);
+    if (!key) return;
+    const filePath = join(this.uploadDir, key);
+    if (existsSync(filePath)) {
+      unlinkSync(filePath);
+    }
+  }
+  getPublicUrl(key) {
+    return `${this.baseUrl}/${key}`;
+  }
+  urlToKey(url) {
+    const prefix = `${this.baseUrl}/`;
+    if (url.startsWith(prefix)) {
+      return url.slice(prefix.length);
+    }
+    return null;
+  }
+};
+function loadDriver5() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    return require2("@aws-sdk/client-s3");
+  } catch {
+    throw new Error(
+      "@aws-sdk/client-s3 is not installed. Run: bun add @aws-sdk/client-s3"
+    );
+  }
+}
+var S3Adapter = class {
+  client;
+  bucket;
+  publicRead;
+  baseUrl;
+  aws;
+  constructor(config) {
+    this.aws = loadDriver5();
+    this.bucket = config.bucket;
+    this.publicRead = config.publicRead ?? true;
+    this.client = new this.aws.S3Client({
+      region: config.region,
+      endpoint: config.endpoint,
+      credentials: {
+        accessKeyId: config.accessKeyId,
+        secretAccessKey: config.secretAccessKey
+      },
+      forcePathStyle: !!config.endpoint
+    });
+    if (config.endpoint) {
+      this.baseUrl = `${config.endpoint.replace(/\/$/, "")}/${config.bucket}`;
+    } else {
+      this.baseUrl = `https://${config.bucket}.s3.${config.region}.amazonaws.com`;
+    }
+  }
+  async upload(file, filename, options) {
+    const safeName = filename.replace(/[^a-zA-Z0-9._/-]/g, "_");
+    const key = `${Date.now()}-${safeName}`;
+    const contentType = options?.contentType ?? guessContentType(filename);
+    const command = new this.aws.PutObjectCommand({
+      Bucket: this.bucket,
+      Key: key,
+      Body: file,
+      ContentType: contentType,
+      ACL: this.publicRead ? "public-read" : "private"
+    });
+    await this.client.send(command);
+    return this.getPublicUrl(key);
+  }
+  async delete(url) {
+    const key = this.urlToKey(url);
+    if (!key) return;
+    const command = new this.aws.DeleteObjectCommand({
+      Bucket: this.bucket,
+      Key: key
+    });
+    await this.client.send(command);
+  }
+  getPublicUrl(key) {
+    return `${this.baseUrl}/${key}`;
+  }
+  urlToKey(url) {
+    const prefix = `${this.baseUrl}/`;
+    if (url.startsWith(prefix)) {
+      return url.slice(prefix.length);
+    }
+    return null;
+  }
+};
+function guessContentType(filename) {
+  const ext = extname(filename).toLowerCase();
+  const map = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".svg": "image/svg+xml",
+    ".avif": "image/avif"
+  };
+  return map[ext] ?? "application/octet-stream";
+}
+
+// src/adapters/storage/external/ExternalURLAdapter.ts
+var ExternalURLAdapter = class {
+  async upload(_file, _filename, _options) {
+    throw new Error(
+      "ExternalURLAdapter does not support uploads. Pass the image URL directly in CreateImageInput.url."
+    );
+  }
+  async delete(_url) {
+  }
+  getPublicUrl(key) {
+    return key;
+  }
+};
+
+export { ExternalURLAdapter, Installer, LocalStorageAdapter, MongoDBAdapter, MySQLAdapter, OnlineCatalog, PostgresAdapter, RedisAdapter, S3Adapter, SQLiteAdapter, assertRichTextDocument, blockquote, document, heading, image, isRichTextDocument, link, orderedList, paragraph, text, unorderedList };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map