@hasna/connectors 0.7.2 → 0.8.0

package/connectors/connect-alttextai/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-alttextai/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/connectors/connect-amadeus/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@hasna/connect-amadeus",
+  "version": "0.0.1",
+  "description": "Amadeus API connector - Flight search, booking, and travel data",
+  "type": "module",
+  "bin": {
+    "connect-amadeus": "./bin/index.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun && bun build ./src/cli/index.ts --outdir ./bin --target bun",
+    "dev": "bun run ./src/cli/index.ts",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": [
+    "amadeus",
+    "flights",
+    "travel",
+    "booking",
+    "api",
+    "connector",
+    "cli"
+  ],
+  "author": "Hasna",
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hasna/open-connectors.git"
+  }
+}

package/connectors/connect-amadeus/src/api/client.ts

@@ -0,0 +1,135 @@
+import type { TokenResponse, AmadeusError } from '../types';
+import { AmadeusApiError } from '../types';
+
+const BASE_URLS = {
+  test: 'https://test.api.amadeus.com',
+  production: 'https://api.amadeus.com',
+};
+
+export interface AmadeusClientConfig {
+  apiKey: string;
+  apiSecret: string;
+  environment?: 'test' | 'production';
+}
+
+export class AmadeusClient {
+  private apiKey: string;
+  private apiSecret: string;
+  private baseUrl: string;
+  private accessToken: string | null = null;
+  private tokenExpiry: number = 0;
+
+  constructor(config: AmadeusClientConfig) {
+    this.apiKey = config.apiKey;
+    this.apiSecret = config.apiSecret;
+    this.baseUrl = BASE_URLS[config.environment || 'test'];
+  }
+
+  private async getAccessToken(): Promise<string> {
+    // Return cached token if still valid (with 60s buffer)
+    if (this.accessToken && Date.now() < this.tokenExpiry - 60000) {
+      return this.accessToken;
+    }
+
+    const response = await fetch(this.baseUrl + '/v1/security/oauth2/token', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: new URLSearchParams({
+        grant_type: 'client_credentials',
+        client_id: this.apiKey,
+        client_secret: this.apiSecret,
+      }).toString(),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new AmadeusApiError('Authentication failed: ' + errorText, response.status);
+    }
+
+    const data: TokenResponse = await response.json();
+    this.accessToken = data.access_token;
+    this.tokenExpiry = Date.now() + (data.expires_in * 1000);
+    return this.accessToken;
+  }
+
+  async get<T>(path: string, params?: Record<string, any>): Promise<T> {
+    const token = await this.getAccessToken();
+    
+    let url = this.baseUrl + path;
+    if (params) {
+      const searchParams = new URLSearchParams();
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== undefined && value !== null) {
+          searchParams.append(key, String(value));
+        }
+      });
+      const queryString = searchParams.toString();
+      if (queryString) url += '?' + queryString;
+    }
+
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: {
+        'Authorization': 'Bearer ' + token,
+        'Accept': 'application/json',
+      },
+    });
+
+    return this.handleResponse<T>(response);
+  }
+
+  async post<T>(path: string, body: any, params?: Record<string, any>): Promise<T> {
+    const token = await this.getAccessToken();
+    
+    let url = this.baseUrl + path;
+    if (params) {
+      const searchParams = new URLSearchParams();
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== undefined && value !== null) {
+          searchParams.append(key, String(value));
+        }
+      });
+      const queryString = searchParams.toString();
+      if (queryString) url += '?' + queryString;
+    }
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Authorization': 'Bearer ' + token,
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+      },
+      body: JSON.stringify(body),
+    });
+
+    return this.handleResponse<T>(response);
+  }
+
+  private async handleResponse<T>(response: Response): Promise<T> {
+    const text = await response.text();
+    
+    if (!response.ok) {
+      let errors: AmadeusError[] = [];
+      try {
+        const errorData = JSON.parse(text);
+        errors = errorData.errors || [];
+      } catch { /* ignore parse errors */ }
+      
+      const message = errors.length > 0 
+        ? errors.map(e => e.detail || e.title).join('; ')
+        : 'API request failed: ' + response.status;
+      
+      throw new AmadeusApiError(message, response.status, errors);
+    }
+
+    if (!text) return {} as T;
+    return JSON.parse(text) as T;
+  }
+
+  getBaseUrl(): string {
+    return this.baseUrl;
+  }
+}

package/connectors/connect-amadeus/src/api/flights.ts

@@ -0,0 +1,129 @@
+import type { AmadeusClient } from './client';
+import type {
+  FlightSearchParams,
+  FlightOffersResponse,
+  FlightPriceResponse,
+  FlightOffer,
+  LocationsResponse,
+  FlightDestinationsResponse,
+  Airline,
+} from '../types';
+
+export class FlightsApi {
+  constructor(private readonly client: AmadeusClient) {}
+
+  /**
+   * Search for flight offers
+   */
+  async searchOffers(params: FlightSearchParams): Promise<FlightOffersResponse> {
+    const queryParams: Record<string, any> = {
+      originLocationCode: params.originLocationCode,
+      destinationLocationCode: params.destinationLocationCode,
+      departureDate: params.departureDate,
+      adults: params.adults,
+    };
+
+    if (params.returnDate) queryParams.returnDate = params.returnDate;
+    if (params.children) queryParams.children = params.children;
+    if (params.infants) queryParams.infants = params.infants;
+    if (params.travelClass) queryParams.travelClass = params.travelClass;
+    if (params.nonStop !== undefined) queryParams.nonStop = params.nonStop;
+    if (params.currencyCode) queryParams.currencyCode = params.currencyCode;
+    if (params.maxPrice) queryParams.maxPrice = params.maxPrice;
+    if (params.max) queryParams.max = params.max;
+
+    return this.client.get<FlightOffersResponse>('/v2/shopping/flight-offers', queryParams);
+  }
+
+  /**
+   * Confirm pricing for selected flight offers
+   */
+  async priceOffers(flightOffers: FlightOffer[]): Promise<FlightPriceResponse> {
+    return this.client.post<FlightPriceResponse>('/v1/shopping/flight-offers/pricing', {
+      data: {
+        type: 'flight-offers-pricing',
+        flightOffers,
+      },
+    });
+  }
+
+  /**
+   * Search for airports and cities by keyword
+   */
+  async searchLocations(keyword: string, subType?: 'AIRPORT' | 'CITY'): Promise<LocationsResponse> {
+    const params: Record<string, any> = {
+      keyword,
+      subType: subType || 'AIRPORT,CITY',
+    };
+    return this.client.get<LocationsResponse>('/v1/reference-data/locations', params);
+  }
+
+  /**
+   * Get airport/city by IATA code
+   */
+  async getLocation(iataCode: string): Promise<LocationsResponse> {
+    return this.client.get<LocationsResponse>('/v1/reference-data/locations/' + iataCode);
+  }
+
+  /**
+   * Find cheapest flight destinations from origin
+   */
+  async inspirationSearch(origin: string, options?: {
+    departureDate?: string;
+    oneWay?: boolean;
+    duration?: string;
+    nonStop?: boolean;
+    maxPrice?: number;
+    viewBy?: 'DATE' | 'DESTINATION' | 'DURATION' | 'WEEK';
+  }): Promise<FlightDestinationsResponse> {
+    const params: Record<string, any> = { origin };
+    if (options?.departureDate) params.departureDate = options.departureDate;
+    if (options?.oneWay !== undefined) params.oneWay = options.oneWay;
+    if (options?.duration) params.duration = options.duration;
+    if (options?.nonStop !== undefined) params.nonStop = options.nonStop;
+    if (options?.maxPrice) params.maxPrice = options.maxPrice;
+    if (options?.viewBy) params.viewBy = options.viewBy;
+
+    return this.client.get<FlightDestinationsResponse>('/v1/shopping/flight-destinations', params);
+  }
+
+  /**
+   * Get cheapest dates for a route
+   */
+  async cheapestDates(origin: string, destination: string, options?: {
+    departureDate?: string;
+    oneWay?: boolean;
+    duration?: string;
+    nonStop?: boolean;
+    maxPrice?: number;
+    viewBy?: 'DATE' | 'DURATION' | 'WEEK';
+  }): Promise<FlightDestinationsResponse> {
+    const params: Record<string, any> = { origin, destination };
+    if (options?.departureDate) params.departureDate = options.departureDate;
+    if (options?.oneWay !== undefined) params.oneWay = options.oneWay;
+    if (options?.duration) params.duration = options.duration;
+    if (options?.nonStop !== undefined) params.nonStop = options.nonStop;
+    if (options?.maxPrice) params.maxPrice = options.maxPrice;
+    if (options?.viewBy) params.viewBy = options.viewBy;
+
+    return this.client.get<FlightDestinationsResponse>('/v1/shopping/flight-dates', params);
+  }
+
+  /**
+   * Get airline information by IATA code
+   */
+  async getAirline(airlineCode: string): Promise<{ data: Airline[] }> {
+    return this.client.get<{ data: Airline[] }>('/v1/reference-data/airlines', {
+      airlineCodes: airlineCode,
+    });
+  }
+
+  /**
+   * Search airlines by name
+   */
+  async searchAirlines(keyword: string): Promise<{ data: Airline[] }> {
+    return this.client.get<{ data: Airline[] }>('/v1/reference-data/airlines', {
+      keyword,
+    });
+  }
+}

package/connectors/connect-amadeus/src/api/index.ts

@@ -0,0 +1,34 @@
+import { AmadeusClient, type AmadeusClientConfig } from './client';
+import { FlightsApi } from './flights';
+
+export class Amadeus {
+  private client: AmadeusClient;
+  public readonly flights: FlightsApi;
+
+  constructor(config: AmadeusClientConfig) {
+    this.client = new AmadeusClient(config);
+    this.flights = new FlightsApi(this.client);
+  }
+
+  static fromEnv(): Amadeus {
+    const apiKey = process.env.AMADEUS_API_KEY;
+    const apiSecret = process.env.AMADEUS_API_SECRET;
+
+    if (!apiKey || !apiSecret) {
+      throw new Error('AMADEUS_API_KEY and AMADEUS_API_SECRET environment variables are required');
+    }
+
+    return new Amadeus({
+      apiKey,
+      apiSecret,
+      environment: process.env.AMADEUS_ENVIRONMENT === 'production' ? 'production' : 'test',
+    });
+  }
+
+  getEnvironment(): string {
+    return this.client.getBaseUrl().includes('test') ? 'test' : 'production';
+  }
+}
+
+export { AmadeusClient } from './client';
+export { FlightsApi } from './flights';