@hasna/connectors 0.9.0 → 0.9.1

package/connectors/connect-datarobot/src/utils/storage.ts

@@ -0,0 +1,198 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { getConfigDir } from './config';
+
+// ============================================
+// Generic Data Storage Utility
+// ============================================
+
+/**
+ * Base interface for storable entities
+ * All stored entities should have an id field
+ */
+export interface Storable {
+  id: string;
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+/**
+ * Get the storage directory for an entity type
+ */
+function getStorageDir(entityType: string): string {
+  const dir = join(getConfigDir(), 'data', entityType);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+
+/**
+ * Convert an ID to a safe filename
+ */
+function idToFilename(id: string): string {
+  return id.toLowerCase().replace(/[^a-z0-9]/g, '_') + '.json';
+}
+
+/**
+ * Get the file path for an entity
+ */
+function getEntityPath(entityType: string, id: string): string {
+  return join(getStorageDir(entityType), idToFilename(id));
+}
+
+/**
+ * Save an entity to storage
+ */
+export function saveEntity<T extends Storable>(entityType: string, entity: T): void {
+  const filepath = getEntityPath(entityType, entity.id);
+  const now = new Date().toISOString();
+
+  const existing = getEntity<T>(entityType, entity.id);
+
+  const data: T = {
+    ...entity,
+    createdAt: existing?.createdAt || now,
+    updatedAt: now,
+  };
+
+  writeFileSync(filepath, JSON.stringify(data, null, 2));
+}
+
+/**
+ * Get an entity by ID
+ */
+export function getEntity<T extends Storable>(entityType: string, id: string): T | null {
+  const filepath = getEntityPath(entityType, id);
+
+  if (!existsSync(filepath)) {
+    return null;
+  }
+
+  try {
+    const content = readFileSync(filepath, 'utf-8');
+    return JSON.parse(content) as T;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if an entity exists
+ */
+export function entityExists(entityType: string, id: string): boolean {
+  return existsSync(getEntityPath(entityType, id));
+}
+
+/**
+ * Get all entities of a type
+ */
+export function getAllEntities<T extends Storable>(entityType: string): T[] {
+  const storageDir = getStorageDir(entityType);
+  const files = readdirSync(storageDir).filter(f => f.endsWith('.json'));
+
+  const entities: T[] = [];
+  for (const file of files) {
+    try {
+      const content = readFileSync(join(storageDir, file), 'utf-8');
+      entities.push(JSON.parse(content) as T);
+    } catch {
+      // Skip invalid files
+    }
+  }
+
+  return entities.sort((a, b) => a.id.localeCompare(b.id));
+}
+
+/**
+ * Delete an entity
+ */
+export function deleteEntity(entityType: string, id: string): boolean {
+  const filepath = getEntityPath(entityType, id);
+
+  if (existsSync(filepath)) {
+    unlinkSync(filepath);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Search entities by a predicate function
+ */
+export function searchEntities<T extends Storable>(
+  entityType: string,
+  predicate: (entity: T) => boolean
+): T[] {
+  const all = getAllEntities<T>(entityType);
+  return all.filter(predicate);
+}
+
+/**
+ * Search entities by text match across all string fields
+ */
+export function searchEntitiesByText<T extends Storable>(
+  entityType: string,
+  query: string,
+  fields?: (keyof T)[]
+): T[] {
+  const all = getAllEntities<T>(entityType);
+  const q = query.toLowerCase();
+
+  return all.filter(entity => {
+    const searchFields = fields || (Object.keys(entity) as (keyof T)[]);
+    return searchFields.some(field => {
+      const value = entity[field];
+      if (typeof value === 'string') {
+        return value.toLowerCase().includes(q);
+      }
+      return false;
+    });
+  });
+}
+
+/**
+ * Count entities of a type
+ */
+export function countEntities(entityType: string): number {
+  const storageDir = getStorageDir(entityType);
+  if (!existsSync(storageDir)) {
+    return 0;
+  }
+  return readdirSync(storageDir).filter(f => f.endsWith('.json')).length;
+}
+
+/**
+ * Clear all entities of a type
+ */
+export function clearEntities(entityType: string): number {
+  const storageDir = getStorageDir(entityType);
+  if (!existsSync(storageDir)) {
+    return 0;
+  }
+
+  const files = readdirSync(storageDir).filter(f => f.endsWith('.json'));
+  for (const file of files) {
+    unlinkSync(join(storageDir, file));
+  }
+
+  return files.length;
+}
+
+/**
+ * Create a typed storage helper for a specific entity type
+ * This provides a cleaner API for working with a single entity type
+ */
+export function createStorage<T extends Storable>(entityType: string) {
+  return {
+    save: (entity: T) => saveEntity<T>(entityType, entity),
+    get: (id: string) => getEntity<T>(entityType, id),
+    exists: (id: string) => entityExists(entityType, id),
+    getAll: () => getAllEntities<T>(entityType),
+    delete: (id: string) => deleteEntity(entityType, id),
+    search: (predicate: (entity: T) => boolean) => searchEntities<T>(entityType, predicate),
+    searchByText: (query: string, fields?: (keyof T)[]) => searchEntitiesByText<T>(entityType, query, fields),
+    count: () => countEntities(entityType),
+    clear: () => clearEntities(entityType),
+  };
+}

package/connectors/connect-datarobot/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "bin"]
+}

package/dist/index.js

@@ -1915,6 +1915,265 @@ var CONNECTORS = [
     description: "Affiliate marketplace and digital product sales",
     category: "Commerce & Finance",
     tags: ["affiliate", "marketplace", "digital"]
+  },
+  {
+    name: "cloudlayer",
+    displayName: "CloudLayer",
+    description: "HTML to PDF and image generation API",
+    category: "Developer Tools",
+    tags: ["pdf", "images", "html", "generation"]
+  },
+  {
+    name: "cloudshare",
+    displayName: "CloudShare",
+    description: "Virtual IT labs and training environments",
+    category: "Developer Tools",
+    tags: ["labs", "training", "virtual-environments"]
+  },
+  {
+    name: "cloze",
+    displayName: "Cloze",
+    description: "AI-powered relationship management CRM",
+    category: "Business Tools",
+    tags: ["crm", "relationships", "ai"]
+  },
+  {
+    name: "cockpit",
+    displayName: "Cockpit",
+    description: "Headless CMS for structured content management",
+    category: "Design & Content",
+    tags: ["cms", "headless", "content"]
+  },
+  {
+    name: "codeclimate",
+    displayName: "Code Climate",
+    description: "Code quality and automated code review",
+    category: "Developer Tools",
+    tags: ["code-quality", "review", "analysis"]
+  },
+  {
+    name: "codefresh",
+    displayName: "Codefresh",
+    description: "CI/CD platform for Kubernetes and GitOps",
+    category: "Developer Tools",
+    tags: ["cicd", "kubernetes", "gitops"]
+  },
+  {
+    name: "cody",
+    displayName: "Cody",
+    description: "AI coding assistant by Sourcegraph",
+    category: "AI & ML",
+    tags: ["ai", "coding", "assistant"]
+  },
+  {
+    name: "coinbase",
+    displayName: "Coinbase",
+    description: "Cryptocurrency accounts, prices, and transactions",
+    category: "Commerce & Finance",
+    tags: ["crypto", "exchange", "payments"]
+  },
+  {
+    name: "collegefootballdata",
+    displayName: "College Football Data",
+    description: "College football statistics and game data",
+    category: "Data & Analytics",
+    tags: ["sports", "football", "statistics"]
+  },
+  {
+    name: "configcat",
+    displayName: "ConfigCat",
+    description: "Feature flags and remote configuration management",
+    category: "Developer Tools",
+    tags: ["feature-flags", "configuration", "remote-config"]
+  },
+  {
+    name: "confluent",
+    displayName: "Confluent",
+    description: "Cloud-native Apache Kafka streaming platform",
+    category: "Developer Tools",
+    tags: ["kafka", "streaming", "events"]
+  },
+  {
+    name: "contactout",
+    displayName: "ContactOut",
+    description: "LinkedIn profile enrichment and contact discovery",
+    category: "Data & Analytics",
+    tags: ["enrichment", "contacts", "linkedin"]
+  },
+  {
+    name: "contentful",
+    displayName: "Contentful",
+    description: "Headless CMS for content management and delivery",
+    category: "Design & Content",
+    tags: ["cms", "headless", "content"]
+  },
+  {
+    name: "convertapi",
+    displayName: "ConvertAPI",
+    description: "File conversion and document processing API",
+    category: "Developer Tools",
+    tags: ["conversion", "documents", "files"]
+  },
+  {
+    name: "convi",
+    displayName: "Convi",
+    description: "Conversational AI and chatbot platform",
+    category: "AI & ML",
+    tags: ["ai", "chatbot", "conversational"]
+  },
+  {
+    name: "copper",
+    displayName: "Copper",
+    description: "CRM built for Google Workspace",
+    category: "Business Tools",
+    tags: ["crm", "google", "sales"]
+  },
+  {
+    name: "copyai",
+    displayName: "Copy.ai",
+    description: "AI-powered copywriting and content generation",
+    category: "AI & ML",
+    tags: ["ai", "copywriting", "content"]
+  },
+  {
+    name: "corsizio",
+    displayName: "Corsizio",
+    description: "Online course and class registration platform",
+    category: "Business Tools",
+    tags: ["courses", "registration", "education"]
+  },
+  {
+    name: "cortex",
+    displayName: "Cortex",
+    description: "Internal developer portal and service catalog",
+    category: "Developer Tools",
+    tags: ["developer-portal", "service-catalog", "microservices"]
+  },
+  {
+    name: "cradlai",
+    displayName: "Cradl AI",
+    description: "AI document parsing and data extraction",
+    category: "AI & ML",
+    tags: ["ai", "document", "extraction"]
+  },
+  {
+    name: "craftdraft",
+    displayName: "CraftDraft",
+    description: "Document drafting and template management",
+    category: "Design & Content",
+    tags: ["documents", "templates", "drafting"]
+  },
+  {
+    name: "cratedb",
+    displayName: "CrateDB",
+    description: "Distributed SQL database for time-series and IoT data",
+    category: "Developer Tools",
+    tags: ["database", "sql", "time-series"]
+  },
+  {
+    name: "cronly",
+    displayName: "Cronly",
+    description: "Cron job monitoring and scheduling",
+    category: "Developer Tools",
+    tags: ["cron", "monitoring", "scheduling"]
+  },
+  {
+    name: "crossmint",
+    displayName: "Crossmint",
+    description: "NFT minting and Web3 wallet infrastructure",
+    category: "Developer Tools",
+    tags: ["nft", "web3", "blockchain"]
+  },
+  {
+    name: "crowddev",
+    displayName: "Crowd.dev",
+    description: "Developer community analytics and engagement",
+    category: "Data & Analytics",
+    tags: ["community", "analytics", "developer-relations"]
+  },
+  {
+    name: "crowdin",
+    displayName: "Crowdin",
+    description: "Localization and translation management platform",
+    category: "Developer Tools",
+    tags: ["localization", "translation", "i18n"]
+  },
+  {
+    name: "crowdpower",
+    displayName: "CrowdPower",
+    description: "Customer engagement and lifecycle automation",
+    category: "Communication",
+    tags: ["engagement", "automation", "lifecycle"]
+  },
+  {
+    name: "crowdstrike",
+    displayName: "CrowdStrike",
+    description: "Endpoint security and threat intelligence platform",
+    category: "Developer Tools",
+    tags: ["security", "endpoint", "threat-intelligence"]
+  },
+  {
+    name: "cryptolens",
+    displayName: "Cryptolens",
+    description: "Software licensing and key management",
+    category: "Developer Tools",
+    tags: ["licensing", "keys", "software"]
+  },
+  {
+    name: "currents",
+    displayName: "Currents",
+    description: "News aggregation and current events API",
+    category: "Data & Analytics",
+    tags: ["news", "articles", "current-events"]
+  },
+  {
+    name: "customeriq",
+    displayName: "CustomerIQ",
+    description: "AI-powered customer feedback analysis",
+    category: "AI & ML",
+    tags: ["ai", "feedback", "customer-insights"]
+  },
+  {
+    name: "daffy",
+    displayName: "Daffy",
+    description: "Donor-advised fund and charitable giving platform",
+    category: "Commerce & Finance",
+    tags: ["donations", "charity", "giving"]
+  },
+  {
+    name: "danteai",
+    displayName: "Dante AI",
+    description: "AI chatbot platform with custom knowledge bases",
+    category: "AI & ML",
+    tags: ["ai", "chatbot", "knowledge-base"]
+  },
+  {
+    name: "darkskyapi",
+    displayName: "Dark Sky",
+    description: "Hyperlocal weather forecasting and historical data",
+    category: "Data & Analytics",
+    tags: ["weather", "forecasting", "climate"]
+  },
+  {
+    name: "dasha",
+    displayName: "Dasha",
+    description: "Conversational AI for voice and text applications",
+    category: "AI & ML",
+    tags: ["ai", "voice", "conversational"]
+  },
+  {
+    name: "databox",
+    displayName: "Databox",
+    description: "Business analytics dashboards and KPI tracking",
+    category: "Data & Analytics",
+    tags: ["analytics", "dashboards", "kpi"]
+  },
+  {
+    name: "datarobot",
+    displayName: "DataRobot",
+    description: "Enterprise AI platform for automated machine learning",
+    category: "AI & ML",
+    tags: ["ai", "ml", "automl", "enterprise"]
   }
 ];
 function getConnectorsByCategory(category) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/connectors",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "Open source connector library - Install API connectors with a single command",
   "type": "module",
   "bin": {