@hasna/connectors 1.0.1 → 1.0.2

package/connectors/connect-leadboxer/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-leadboxer/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

@@ -16,7 +16,10 @@ var CATEGORIES = [
   "Data & Analytics",
   "Business Tools",
   "Patents & IP",
-  "Advertising"
+  "Advertising",
+  "Security & Compliance",
+  "Marketing & Sales",
+  "Infrastructure"
 ];
 var CONNECTORS = [
   {
@@ -3119,6 +3122,279 @@ var CONNECTORS = [
     description: "Time series database and analytics",
     category: "Data & Analytics",
     tags: ["timeseries", "database", "monitoring", "iot"]
+  },
+  {
+    name: "infolobby",
+    displayName: "InfoLobby",
+    description: "Cloud database and business applications platform",
+    category: "Business Tools",
+    tags: ["database", "business", "applications"]
+  },
+  {
+    name: "instabot",
+    displayName: "Instabot",
+    description: "Chatbot and conversational marketing platform",
+    category: "Marketing & Sales",
+    tags: ["chatbot", "marketing", "automation"]
+  },
+  {
+    name: "instabug",
+    displayName: "Instabug",
+    description: "Bug reporting and crash analytics for mobile apps",
+    category: "Developer Tools",
+    tags: ["bugs", "mobile", "crash-reporting", "analytics"]
+  },
+  {
+    name: "intakeq",
+    displayName: "IntakeQ",
+    description: "Online intake forms and practice management for health professionals",
+    category: "Business Tools",
+    tags: ["healthcare", "forms", "intake", "practice-management"]
+  },
+  {
+    name: "invoiced",
+    displayName: "Invoiced",
+    description: "Accounts receivable automation and invoicing",
+    category: "Commerce & Finance",
+    tags: ["invoicing", "billing", "accounts-receivable"]
+  },
+  {
+    name: "invoiceninja",
+    displayName: "Invoice Ninja",
+    description: "Open-source invoicing, payments, and accounting",
+    category: "Commerce & Finance",
+    tags: ["invoicing", "payments", "accounting", "open-source"]
+  },
+  {
+    name: "ip2location",
+    displayName: "IP2Location",
+    description: "IP geolocation and proxy detection",
+    category: "Data & Analytics",
+    tags: ["ip", "geolocation", "proxy-detection"]
+  },
+  {
+    name: "ipinfo",
+    displayName: "IPinfo",
+    description: "IP address data and geolocation API",
+    category: "Data & Analytics",
+    tags: ["ip", "geolocation", "network"]
+  },
+  {
+    name: "ipregistry",
+    displayName: "ipregistry",
+    description: "IP geolocation and threat detection API",
+    category: "Data & Analytics",
+    tags: ["ip", "geolocation", "threat-detection"]
+  },
+  {
+    name: "irisdfir",
+    displayName: "IRIS DFIR",
+    description: "Digital forensics and incident response platform",
+    category: "Security & Compliance",
+    tags: ["dfir", "forensics", "incident-response", "security"]
+  },
+  {
+    name: "isn",
+    displayName: "ISN",
+    description: "ISNetworld contractor management and compliance",
+    category: "Business Tools",
+    tags: ["compliance", "contractor", "safety"]
+  },
+  {
+    name: "iterable",
+    displayName: "Iterable",
+    description: "Cross-channel marketing automation platform",
+    category: "Marketing & Sales",
+    tags: ["marketing", "email", "automation", "cross-channel"]
+  },
+  {
+    name: "jama",
+    displayName: "Jama Software",
+    description: "Requirements management and traceability",
+    category: "Developer Tools",
+    tags: ["requirements", "traceability", "product-development"]
+  },
+  {
+    name: "jasper",
+    displayName: "Jasper",
+    description: "AI content generation and marketing copy",
+    category: "AI & ML",
+    tags: ["ai", "content", "copywriting", "marketing"]
+  },
+  {
+    name: "jenkins",
+    displayName: "Jenkins",
+    description: "Open-source CI/CD automation server",
+    category: "Developer Tools",
+    tags: ["ci-cd", "automation", "devops", "open-source"]
+  },
+  {
+    name: "jinaai",
+    displayName: "Jina AI",
+    description: "Neural search and embedding models",
+    category: "AI & ML",
+    tags: ["ai", "search", "embeddings", "neural"]
+  },
+  {
+    name: "kadoa",
+    displayName: "Kadoa",
+    description: "AI-powered web scraping and data extraction",
+    category: "Data & Analytics",
+    tags: ["scraping", "data-extraction", "ai"]
+  },
+  {
+    name: "kafka",
+    displayName: "Apache Kafka",
+    description: "Distributed event streaming platform",
+    category: "Infrastructure",
+    tags: ["streaming", "messaging", "events", "distributed"]
+  },
+  {
+    name: "kaggle",
+    displayName: "Kaggle",
+    description: "Data science competitions, datasets, and notebooks",
+    category: "Data & Analytics",
+    tags: ["data-science", "datasets", "ml", "competitions"]
+  },
+  {
+    name: "kanbantool",
+    displayName: "Kanban Tool",
+    description: "Visual project management with Kanban boards",
+    category: "Business Tools",
+    tags: ["kanban", "project-management", "boards"]
+  },
+  {
+    name: "karbon",
+    displayName: "Karbon",
+    description: "Practice management for accounting firms",
+    category: "Business Tools",
+    tags: ["accounting", "practice-management", "workflow"]
+  },
+  {
+    name: "keap",
+    displayName: "Keap",
+    description: "CRM, sales, and marketing automation for small business",
+    category: "Marketing & Sales",
+    tags: ["crm", "marketing", "automation", "small-business"]
+  },
+  {
+    name: "keygen",
+    displayName: "Keygen",
+    description: "Software licensing and distribution API",
+    category: "Developer Tools",
+    tags: ["licensing", "software", "distribution", "api"]
+  },
+  {
+    name: "keyzy",
+    displayName: "Keyzy",
+    description: "Rent-to-own property platform",
+    category: "Commerce & Finance",
+    tags: ["property", "rent-to-own", "real-estate"]
+  },
+  {
+    name: "kibana",
+    displayName: "Kibana",
+    description: "Data visualization and exploration for Elasticsearch",
+    category: "Data & Analytics",
+    tags: ["visualization", "elasticsearch", "dashboards", "logging"]
+  },
+  {
+    name: "kitemaker",
+    displayName: "Kitemaker",
+    description: "Issue tracking and project management for product teams",
+    category: "Developer Tools",
+    tags: ["issue-tracking", "project-management", "product"]
+  },
+  {
+    name: "klazify",
+    displayName: "Klazify",
+    description: "Website categorization and logo detection API",
+    category: "Data & Analytics",
+    tags: ["categorization", "website", "logo-detection"]
+  },
+  {
+    name: "kling",
+    displayName: "Kling AI",
+    description: "AI video generation and editing",
+    category: "AI & ML",
+    tags: ["ai", "video", "generation"]
+  },
+  {
+    name: "knack",
+    displayName: "Knack",
+    description: "No-code online database and web app builder",
+    category: "Business Tools",
+    tags: ["no-code", "database", "web-apps"]
+  },
+  {
+    name: "knowbe4",
+    displayName: "KnowBe4",
+    description: "Security awareness training and phishing simulation",
+    category: "Security & Compliance",
+    tags: ["security", "training", "phishing", "awareness"]
+  },
+  {
+    name: "kobotoolbox",
+    displayName: "KoboToolbox",
+    description: "Data collection and survey tools for field research",
+    category: "Data & Analytics",
+    tags: ["surveys", "data-collection", "field-research", "humanitarian"]
+  },
+  {
+    name: "kraftful",
+    displayName: "Kraftful",
+    description: "AI-powered product feedback analysis",
+    category: "AI & ML",
+    tags: ["ai", "product", "feedback", "analytics"]
+  },
+  {
+    name: "lagrowthmachine",
+    displayName: "La Growth Machine",
+    description: "Multi-channel sales automation and outreach",
+    category: "Marketing & Sales",
+    tags: ["sales", "outreach", "automation", "multi-channel"]
+  },
+  {
+    name: "lambdatest",
+    displayName: "LambdaTest",
+    description: "Cross-browser testing and test automation platform",
+    category: "Developer Tools",
+    tags: ["testing", "browser", "automation", "cross-browser"]
+  },
+  {
+    name: "landbot",
+    displayName: "Landbot",
+    description: "No-code chatbot builder for websites and messaging",
+    category: "Marketing & Sales",
+    tags: ["chatbot", "no-code", "messaging", "lead-generation"]
+  },
+  {
+    name: "laposta",
+    displayName: "Laposta",
+    description: "Email marketing and newsletter platform",
+    category: "Marketing & Sales",
+    tags: ["email", "newsletter", "marketing"]
+  },
+  {
+    name: "launch27",
+    displayName: "Launch27",
+    description: "Online booking and scheduling for service businesses",
+    category: "Business Tools",
+    tags: ["booking", "scheduling", "services"]
+  },
+  {
+    name: "ldap",
+    displayName: "LDAP",
+    description: "Lightweight Directory Access Protocol for directory services",
+    category: "Infrastructure",
+    tags: ["directory", "authentication", "ldap", "identity"]
+  },
+  {
+    name: "leadboxer",
+    displayName: "LeadBoxer",
+    description: "Lead identification and website visitor tracking",
+    category: "Marketing & Sales",
+    tags: ["leads", "tracking", "visitor-identification", "b2b"]
   }
 ];
 function getConnectorsByCategory(category) {

package/dist/lib/registry.d.ts

@@ -9,7 +9,7 @@ export interface ConnectorMeta {
     tags: string[];
     version?: string;
 }
-export declare const CATEGORIES: readonly ["AI & ML", "Developer Tools", "Design & Content", "Communication", "Social Media", "Commerce & Finance", "Google Workspace", "Data & Analytics", "Business Tools", "Patents & IP", "Advertising"];
+export declare const CATEGORIES: readonly ["AI & ML", "Developer Tools", "Design & Content", "Communication", "Social Media", "Commerce & Finance", "Google Workspace", "Data & Analytics", "Business Tools", "Patents & IP", "Advertising", "Security & Compliance", "Marketing & Sales", "Infrastructure"];
 export type Category = (typeof CATEGORIES)[number];
 export declare const CONNECTORS: ConnectorMeta[];
 export declare function getConnectorsByCategory(category: Category): ConnectorMeta[];

package/package.json

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