@mixpeek/contentful 1.0.0

package/src/modules/contentfulClient.js

@@ -0,0 +1,92 @@
+/**
+ * @mixpeek/contentful — ContentfulClient
+ *
+ * Contentful Management API client for reading/writing enrichment data
+ */
+
+import { createClient } from '../api/mixpeekClient.js';
+import { createCacheManager } from '../cache/cacheManager.js';
+import { getLogger } from '../utils/logger.js';
+import { DEFAULT_CONFIG } from '../config/constants.js';
+
+class ContentfulClient {
+  /**
+   * @param {Object} config
+   * @param {string} config.apiKey - Mixpeek API key
+   * @param {string} [config.endpoint] - API endpoint
+   * @param {number} [config.timeout] - Request timeout in ms
+   * @param {number} [config.cacheTTL] - Cache TTL in seconds
+   * @param {boolean} [config.enableCache] - Enable caching
+   * @param {boolean} [config.debug] - Enable debug logging
+   */
+  constructor(config = {}) {
+    if (!config.apiKey) throw new Error('apiKey is required for ContentfulClient');
+
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.client = createClient({
+      apiKey: config.apiKey,
+      endpoint: this.config.endpoint,
+      timeout: this.config.timeout,
+      debug: this.config.debug
+    });
+    this.cache = this.config.enableCache ? createCacheManager({ ttl: this.config.cacheTTL, debug: this.config.debug }) : null;
+    this.logger = getLogger({ debug: this.config.debug });
+    this.metrics = { requests: 0, errors: 0, totalLatencyMs: 0 };
+    this.logger.info('ContentfulClient initialized');
+  }
+
+  async getEntry(...args) {
+    this.logger.debug('ContentfulClient.getEntry called');
+    // TODO: Implement getEntry
+    throw new Error('ContentfulClient.getEntry not yet implemented');
+  }
+
+  async getEntries(...args) {
+    this.logger.debug('ContentfulClient.getEntries called');
+    // TODO: Implement getEntries
+    throw new Error('ContentfulClient.getEntries not yet implemented');
+  }
+
+  async updateEntry(...args) {
+    this.logger.debug('ContentfulClient.updateEntry called');
+    // TODO: Implement updateEntry
+    throw new Error('ContentfulClient.updateEntry not yet implemented');
+  }
+
+  async getAsset(...args) {
+    this.logger.debug('ContentfulClient.getAsset called');
+    // TODO: Implement getAsset
+    throw new Error('ContentfulClient.getAsset not yet implemented');
+  }
+
+  async publishEntry(...args) {
+    this.logger.debug('ContentfulClient.publishEntry called');
+    // TODO: Implement publishEntry
+    throw new Error('ContentfulClient.publishEntry not yet implemented');
+  }
+
+  getMetrics() {
+    return {
+      ...this.metrics,
+      avgLatencyMs: this.metrics.requests > 0 ? this.metrics.totalLatencyMs / this.metrics.requests : 0,
+      cache: this.cache ? this.cache.getStats() : null
+    };
+  }
+
+  resetMetrics() {
+    this.metrics = { requests: 0, errors: 0, totalLatencyMs: 0 };
+    if (this.cache) this.cache.resetStats();
+  }
+
+  destroy() {
+    if (this.cache) this.cache.destroy();
+    this.logger.info('ContentfulClient destroyed');
+  }
+}
+
+export function createContentfulClient(config) {
+  return new ContentfulClient(config);
+}
+
+export { ContentfulClient };
+export default { createContentfulClient, ContentfulClient };

package/src/modules/webhookHandler.js

@@ -0,0 +1,92 @@
+/**
+ * @mixpeek/contentful — WebhookHandler
+ *
+ * Handles Contentful webhooks (entry publish/unpublish/archive) and triggers enrichment
+ */
+
+import { createClient } from '../api/mixpeekClient.js';
+import { createCacheManager } from '../cache/cacheManager.js';
+import { getLogger } from '../utils/logger.js';
+import { DEFAULT_CONFIG } from '../config/constants.js';
+
+class WebhookHandler {
+  /**
+   * @param {Object} config
+   * @param {string} config.apiKey - Mixpeek API key
+   * @param {string} [config.endpoint] - API endpoint
+   * @param {number} [config.timeout] - Request timeout in ms
+   * @param {number} [config.cacheTTL] - Cache TTL in seconds
+   * @param {boolean} [config.enableCache] - Enable caching
+   * @param {boolean} [config.debug] - Enable debug logging
+   */
+  constructor(config = {}) {
+    if (!config.apiKey) throw new Error('apiKey is required for WebhookHandler');
+
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.client = createClient({
+      apiKey: config.apiKey,
+      endpoint: this.config.endpoint,
+      timeout: this.config.timeout,
+      debug: this.config.debug
+    });
+    this.cache = this.config.enableCache ? createCacheManager({ ttl: this.config.cacheTTL, debug: this.config.debug }) : null;
+    this.logger = getLogger({ debug: this.config.debug });
+    this.metrics = { requests: 0, errors: 0, totalLatencyMs: 0 };
+    this.logger.info('WebhookHandler initialized');
+  }
+
+  async handleWebhook(...args) {
+    this.logger.debug('WebhookHandler.handleWebhook called');
+    // TODO: Implement handleWebhook
+    throw new Error('WebhookHandler.handleWebhook not yet implemented');
+  }
+
+  verifySignature(...args) {
+    this.logger.debug('WebhookHandler.verifySignature called');
+    // TODO: Implement verifySignature
+    throw new Error('WebhookHandler.verifySignature not yet implemented');
+  }
+
+  async registerWebhook(...args) {
+    this.logger.debug('WebhookHandler.registerWebhook called');
+    // TODO: Implement registerWebhook
+    throw new Error('WebhookHandler.registerWebhook not yet implemented');
+  }
+
+  async listWebhooks(...args) {
+    this.logger.debug('WebhookHandler.listWebhooks called');
+    // TODO: Implement listWebhooks
+    throw new Error('WebhookHandler.listWebhooks not yet implemented');
+  }
+
+  async deleteWebhook(...args) {
+    this.logger.debug('WebhookHandler.deleteWebhook called');
+    // TODO: Implement deleteWebhook
+    throw new Error('WebhookHandler.deleteWebhook not yet implemented');
+  }
+
+  getMetrics() {
+    return {
+      ...this.metrics,
+      avgLatencyMs: this.metrics.requests > 0 ? this.metrics.totalLatencyMs / this.metrics.requests : 0,
+      cache: this.cache ? this.cache.getStats() : null
+    };
+  }
+
+  resetMetrics() {
+    this.metrics = { requests: 0, errors: 0, totalLatencyMs: 0 };
+    if (this.cache) this.cache.resetStats();
+  }
+
+  destroy() {
+    if (this.cache) this.cache.destroy();
+    this.logger.info('WebhookHandler destroyed');
+  }
+}
+
+export function createWebhookHandler(config) {
+  return new WebhookHandler(config);
+}
+
+export { WebhookHandler };
+export default { createWebhookHandler, WebhookHandler };

package/src/utils/helpers.js

@@ -0,0 +1,49 @@
+/**
+ * @mixpeek/contentful — Helper Utilities
+ */
+
+export function generateId() {
+  return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+
+export function createCacheKey(content) {
+  const str = JSON.stringify(content);
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    hash = ((hash << 5) - hash) + str.charCodeAt(i);
+    hash = hash & hash;
+  }
+  return `mixpeek_${Math.abs(hash).toString(36)}`;
+}
+
+export function sanitizeText(text, maxLength = 50000) {
+  if (!text || typeof text !== 'string') return '';
+  return text.replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim().substring(0, maxLength);
+}
+
+export function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+      result[key] = target[key] && typeof target[key] === 'object' && !Array.isArray(target[key])
+        ? deepMerge(target[key], source[key]) : { ...source[key] };
+    } else if (Array.isArray(source[key])) {
+      result[key] = [...source[key]];
+    } else {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}
+
+export function isValidUrl(url) {
+  if (!url || typeof url !== 'string') return false;
+  try { new URL(url); return true; } catch { return false; }
+}
+
+export function extractDomain(url) {
+  if (!isValidUrl(url)) return null;
+  try { return new URL(url).hostname; } catch { return null; }
+}
+
+export default { generateId, createCacheKey, sanitizeText, deepMerge, isValidUrl, extractDomain };

package/src/utils/logger.js

@@ -0,0 +1,63 @@
+/**
+ * @mixpeek/contentful — Logger Utility
+ */
+
+const LOG_LEVELS = { DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3, NONE: 4 };
+
+class Logger {
+  constructor(options = {}) {
+    this.prefix = options.prefix || '[Mixpeek-Contentful]';
+    this.level = options.debug ? LOG_LEVELS.DEBUG : LOG_LEVELS.INFO;
+    this.enabled = options.enabled !== false;
+    this.timers = new Map();
+  }
+
+  setLevel(level) {
+    this.level = typeof level === 'string' ? (LOG_LEVELS[level.toUpperCase()] ?? LOG_LEVELS.INFO) : level;
+  }
+  setEnabled(enabled) { this.enabled = enabled; }
+
+  _log(level, levelName, ...args) {
+    if (!this.enabled || level < this.level) return;
+    const ts = new Date().toISOString();
+    const formatted = args.map(a => typeof a === 'object' ? JSON.stringify(a, null, 2) : a);
+    const msg = `${ts} ${this.prefix} [${levelName}]`;
+    if (level === LOG_LEVELS.ERROR) console.error(msg, ...formatted);
+    else if (level === LOG_LEVELS.WARN) console.warn(msg, ...formatted);
+    else if (level === LOG_LEVELS.DEBUG) console.debug(msg, ...formatted);
+    else console.log(msg, ...formatted);
+  }
+
+  debug(...args) { this._log(LOG_LEVELS.DEBUG, 'DEBUG', ...args); }
+  info(...args) { this._log(LOG_LEVELS.INFO, 'INFO', ...args); }
+  warn(...args) { this._log(LOG_LEVELS.WARN, 'WARN', ...args); }
+  error(...args) { this._log(LOG_LEVELS.ERROR, 'ERROR', ...args); }
+
+  time(label) { this.timers.set(label, performance.now ? performance.now() : Date.now()); }
+  timeEnd(label) {
+    const start = this.timers.get(label);
+    if (!start) return 0;
+    const elapsed = (performance.now ? performance.now() : Date.now()) - start;
+    this.timers.delete(label);
+    this.debug(`${label}: ${elapsed.toFixed(2)}ms`);
+    return elapsed;
+  }
+
+  child(subPrefix) {
+    return new Logger({ prefix: `${this.prefix}[${subPrefix}]`, debug: this.level === LOG_LEVELS.DEBUG, enabled: this.enabled });
+  }
+}
+
+let defaultLogger = null;
+export function getLogger(options = {}) {
+  if (!defaultLogger) { defaultLogger = new Logger(options); }
+  else if (Object.keys(options).length > 0) {
+    if (options.debug !== undefined) defaultLogger.setLevel(options.debug ? 'DEBUG' : 'INFO');
+    if (options.enabled !== undefined) defaultLogger.setEnabled(options.enabled);
+  }
+  return defaultLogger;
+}
+
+export function createLogger(options = {}) { return new Logger(options); }
+export { Logger, LOG_LEVELS };
+export default { getLogger, createLogger, Logger, LOG_LEVELS };