@hasna/connectors 1.3.43 → 1.3.45

package/connectors/vercel-edge-config/src/utils/config.ts

@@ -0,0 +1,188 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, rmSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { DEFAULT_BASE_URL } from '../api/client';
+
+const CONNECTOR_NAME = 'connect-vercel-edge-config';
+const DEFAULT_PROFILE = 'default';
+
+export interface ProfileConfig {
+  apiKey?: string;
+  teamId?: string;
+  baseUrl?: string;
+}
+
+let profileOverride: string | undefined;
+
+const CONFIG_DIR = join(homedir(), '.hasna', 'connectors', CONNECTOR_NAME);
+const PROFILES_DIR = join(CONFIG_DIR, 'profiles');
+const CURRENT_PROFILE_FILE = join(CONFIG_DIR, 'current_profile');
+
+export function setProfileOverride(profile: string | undefined): void {
+  profileOverride = profile;
+}
+
+export function ensureConfigDir(): void {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  if (!existsSync(PROFILES_DIR)) {
+    mkdirSync(PROFILES_DIR, { recursive: true });
+  }
+}
+
+function getProfilePath(profile: string): string {
+  return join(PROFILES_DIR, `${profile}.json`);
+}
+
+export function getCurrentProfile(): string {
+  if (profileOverride) {
+    return profileOverride;
+  }
+
+  ensureConfigDir();
+
+  if (existsSync(CURRENT_PROFILE_FILE)) {
+    try {
+      const profile = readFileSync(CURRENT_PROFILE_FILE, 'utf-8').trim();
+      if (profile && profileExists(profile)) {
+        return profile;
+      }
+    } catch {
+      // Fall through to default
+    }
+  }
+
+  return DEFAULT_PROFILE;
+}
+
+export function setCurrentProfile(profile: string): void {
+  ensureConfigDir();
+
+  if (!profileExists(profile) && profile !== DEFAULT_PROFILE) {
+    throw new Error(`Profile "${profile}" does not exist`);
+  }
+
+  writeFileSync(CURRENT_PROFILE_FILE, profile);
+}
+
+export function profileExists(profile: string): boolean {
+  return existsSync(getProfilePath(profile));
+}
+
+export function listProfiles(): string[] {
+  ensureConfigDir();
+
+  if (!existsSync(PROFILES_DIR)) {
+    return [];
+  }
+
+  return readdirSync(PROFILES_DIR)
+    .filter((f) => f.endsWith('.json'))
+    .map((f) => f.replace('.json', ''))
+    .sort();
+}
+
+export function createProfile(profile: string, config: ProfileConfig = {}): boolean {
+  ensureConfigDir();
+
+  if (profileExists(profile)) {
+    return false;
+  }
+
+  if (!/^[a-zA-Z0-9_-]+$/.test(profile)) {
+    throw new Error('Profile name can only contain letters, numbers, hyphens, and underscores');
+  }
+
+  writeFileSync(getProfilePath(profile), JSON.stringify(config, null, 2));
+  return true;
+}
+
+export function deleteProfile(profile: string): boolean {
+  if (profile === DEFAULT_PROFILE) {
+    return false;
+  }
+
+  if (!profileExists(profile)) {
+    return false;
+  }
+
+  if (getCurrentProfile() === profile) {
+    setCurrentProfile(DEFAULT_PROFILE);
+  }
+
+  rmSync(getProfilePath(profile));
+  return true;
+}
+
+export function loadProfile(profile?: string): ProfileConfig {
+  ensureConfigDir();
+  const profileName = profile || getCurrentProfile();
+  const profilePath = getProfilePath(profileName);
+
+  if (!existsSync(profilePath)) {
+    return {};
+  }
+
+  try {
+    return JSON.parse(readFileSync(profilePath, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+export function saveProfile(config: ProfileConfig, profile?: string): void {
+  ensureConfigDir();
+  const profileName = profile || getCurrentProfile();
+  writeFileSync(getProfilePath(profileName), JSON.stringify(config, null, 2));
+}
+
+export function getApiKey(): string | undefined {
+  return (
+    process.env.VERCEL_TOKEN ||
+    process.env.VERCEL_EDGE_CONFIG_API_KEY ||
+    loadProfile().apiKey
+  );
+}
+
+export function setApiKey(apiKey: string): void {
+  const config = loadProfile();
+  config.apiKey = apiKey;
+  saveProfile(config);
+}
+
+export function getTeamId(): string | undefined {
+  return process.env.VERCEL_TEAM_ID || loadProfile().teamId;
+}
+
+export function setTeamId(teamId: string): void {
+  const config = loadProfile();
+  config.teamId = teamId;
+  saveProfile(config);
+}
+
+export function getBaseUrl(): string {
+  return (
+    process.env.VERCEL_EDGE_CONFIG_BASE_URL ||
+    loadProfile().baseUrl ||
+    DEFAULT_BASE_URL
+  );
+}
+
+export function setBaseUrl(baseUrl: string): void {
+  const config = loadProfile();
+  config.baseUrl = baseUrl;
+  saveProfile(config);
+}
+
+export function clearConfig(): void {
+  saveProfile({});
+}
+
+export function getConfigDir(): string {
+  return CONFIG_DIR;
+}
+
+export function getActiveProfileName(): string {
+  return getCurrentProfile();
+}

package/connectors/vercel-edge-config/src/utils/output.ts

@@ -0,0 +1,116 @@
+import chalk from 'chalk';
+
+export type OutputFormat = 'json' | 'table' | 'pretty';
+
+export function formatOutput(data: unknown, format: OutputFormat = 'pretty'): string {
+  switch (format) {
+    case 'json':
+      return JSON.stringify(data, null, 2);
+    case 'table':
+      return formatAsTable(data);
+    case 'pretty':
+    default:
+      return formatPretty(data);
+  }
+}
+
+function formatAsTable(data: unknown): string {
+  if (!Array.isArray(data)) {
+    data = [data];
+  }
+
+  const items = data as Record<string, unknown>[];
+  if (items.length === 0) {
+    return 'No data';
+  }
+
+  const firstItem = items[0];
+  if (!firstItem || typeof firstItem !== 'object') {
+    return 'No data';
+  }
+
+  const keys = Object.keys(firstItem);
+  const colWidths = keys.map((key) => {
+    const maxValue = Math.max(key.length, ...items.map((item) => String(item[key] ?? '').length));
+    return Math.min(maxValue, 40);
+  });
+
+  const header = keys.map((key, i) => key.padEnd(colWidths[i] ?? 10)).join(' | ');
+  const separator = colWidths.map((w) => '-'.repeat(w)).join('-+-');
+
+  const rows = items.map((item) =>
+    keys
+      .map((key, i) => {
+        const value = String(item[key] ?? '');
+        const width = colWidths[i] ?? 10;
+        return value.length > width ? value.substring(0, width - 3) + '...' : value.padEnd(width);
+      })
+      .join(' | '),
+  );
+
+  return [header, separator, ...rows].join('\n');
+}
+
+function formatPretty(data: unknown): string {
+  if (Array.isArray(data)) {
+    return data.map((item, i) => `${chalk.cyan(`[${i + 1}]`)} ${formatPrettyItem(item)}`).join('\n\n');
+  }
+  return formatPrettyItem(data);
+}
+
+function formatPrettyItem(item: unknown, indent = 0): string {
+  if (item === null || item === undefined) {
+    return chalk.gray('null');
+  }
+
+  if (typeof item !== 'object') {
+    return String(item);
+  }
+
+  const spaces = '  '.repeat(indent);
+  const entries = Object.entries(item as Record<string, unknown>);
+
+  return entries
+    .map(([key, value]) => {
+      if (Array.isArray(value)) {
+        if (value.length === 0) {
+          return `${spaces}${chalk.blue(key)}: ${chalk.gray('[]')}`;
+        }
+        if (typeof value[0] === 'object') {
+          return `${spaces}${chalk.blue(key)}:\n${value.map((v) => formatPrettyItem(v, indent + 1)).join('\n')}`;
+        }
+        return `${spaces}${chalk.blue(key)}: ${value.join(', ')}`;
+      }
+
+      if (typeof value === 'object' && value !== null) {
+        return `${spaces}${chalk.blue(key)}:\n${formatPrettyItem(value, indent + 1)}`;
+      }
+
+      return `${spaces}${chalk.blue(key)}: ${chalk.white(String(value))}`;
+    })
+    .join('\n');
+}
+
+export function success(message: string): void {
+  console.log(chalk.green('✓'), message);
+}
+
+export function error(message: string): void {
+  console.error(chalk.red('✗'), message);
+}
+
+export function warn(message: string): void {
+  console.warn(chalk.yellow('⚠'), message);
+}
+
+export function info(message: string): void {
+  console.log(chalk.blue('ℹ'), message);
+}
+
+export function heading(message: string): void {
+  console.log(chalk.bold.cyan(`\n${message}\n`));
+}
+
+export function print(data: unknown, format: OutputFormat = 'pretty'): void {
+  console.log(formatOutput(data, format));
+}

package/connectors/vercel-edge-config/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/vercel-edge-config-platform/.env.example

@@ -0,0 +1,5 @@
+# Vercel API token (create at https://vercel.com/account/tokens)
+VERCEL_TOKEN=your-vercel-token-here
+
+# Optional: Team ID for team-scoped requests
+# VERCEL_TEAM_ID=team_xxxxxxxxxxxxxxxx

package/connectors/vercel-edge-config-platform/CLAUDE.md

@@ -0,0 +1,40 @@
+# CLAUDE.md
+
+## Project Overview
+
+connect-vercel-edge-config-platform is a TypeScript connector for the Vercel Edge Config **management** REST API at `https://api.vercel.com/v1/edge-config`.
+
+## Build & Run
+
+```bash
+bun install
+bun run dev
+bun run build
+bun run typecheck
+bun test
+```
+
+## Authentication
+
+Bearer token via `VERCEL_TOKEN` or profile config. Optional `VERCEL_TEAM_ID` for team-scoped requests.
+
+## Data Storage
+
+```
+~/.hasna/connectors/connect-vercel-edge-config-platform/
+├── current_profile
+└── profiles/
+    └── default.json
+```
+
+## Scope
+
+Management API only (`api.vercel.com`). Does not use `edge-config.vercel.com` read endpoint.
+
+## API Coverage
+
+- Edge Configs: list, create, get, update, delete
+- Items: list, get, batch patch
+- Schema: get, update, delete
+- Tokens: list, get, create, delete
+- Backups: list, get, restore

package/connectors/vercel-edge-config-platform/README.md

@@ -0,0 +1,75 @@
+# connect-vercel-edge-config-platform
+
+TypeScript connector for the Vercel Edge Config management REST API (`api.vercel.com/v1/edge-config`).
+
+## Features
+
+- Manage Edge Configs (list, create, get, update, delete)
+- Item operations (list, get, batch patch)
+- Schema CRUD
+- Token management
+- Backup list, get, and restore
+- Multi-profile configuration with Bearer token auth
+
+## Quick Start
+
+```bash
+bun install
+bun run dev config set-key <your-vercel-token>
+bun run dev edge-config ls
+```
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `VERCEL_TOKEN` | Vercel API token (overrides profile) |
+| `VERCEL_TEAM_ID` | Team ID for team-scoped requests |
+
+Get a token at https://vercel.com/account/tokens
+
+## CLI Commands
+
+```bash
+# Profiles & config
+connect-vercel-edge-config-platform profile list
+connect-vercel-edge-config-platform config set-key <token>
+connect-vercel-edge-config-platform config set-team <teamId>
+
+# Edge Configs
+connect-vercel-edge-config-platform edge-config ls
+connect-vercel-edge-config-platform edge-config create <slug>
+connect-vercel-edge-config-platform edge-config get <id>
+connect-vercel-edge-config-platform edge-config update <id> <slug>
+connect-vercel-edge-config-platform edge-config delete <id>
+
+# Items
+connect-vercel-edge-config-platform item ls <edgeConfigId>
+connect-vercel-edge-config-platform item get <edgeConfigId> <key>
+connect-vercel-edge-config-platform item patch <edgeConfigId> --items '[{"operation":"upsert","key":"foo","value":true}]'
+
+# Schema, tokens, backups
+connect-vercel-edge-config-platform schema get <edgeConfigId>
+connect-vercel-edge-config-platform token create <edgeConfigId> <label>
+connect-vercel-edge-config-platform backup ls <edgeConfigId>
+connect-vercel-edge-config-platform backup restore <edgeConfigId> <versionId>
+```
+
+## Library Usage
+
+```typescript
+import { EdgeConfigPlatform } from '@hasna/connect-vercel-edge-config-platform';
+
+const client = new EdgeConfigPlatform({ apiKey: process.env.VERCEL_TOKEN! });
+const configs = await client.listEdgeConfigs();
+```
+
+## API Reference
+
+Based on the official Vercel OpenAPI spec: https://openapi.vercel.sh
+
+This connector covers the **management API** at `api.vercel.com`. Runtime reads via `edge-config.vercel.com` are out of scope (see the separate `vercel-edge-config` connector).
+
+## License
+
+Apache-2.0

package/connectors/vercel-edge-config-platform/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@hasna/connect-vercel-edge-config-platform",
+  "version": "0.0.1",
+  "description": "Vercel Edge Config Platform connector - Manage Edge Configs, items, tokens, backups, and schemas",
+  "type": "module",
+  "bin": {
+    "connect-vercel-edge-config-platform": "./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",
+    "test": "bun test",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": [
+    "vercel",
+    "edge-config",
+    "feature-flags",
+    "connector",
+    "cli",
+    "typescript",
+    "bun"
+  ],
+  "author": "Hasna",
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "chalk": "^5.3.0"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hasna/open-connectors.git"
+  }
+}

package/connectors/vercel-edge-config-platform/src/api/client.test.ts

@@ -0,0 +1,157 @@
+import { describe, it, expect, mock } from 'bun:test';
+import { EdgeConfigPlatformClient } from './client';
+import { EdgeConfigPlatform } from './index';
+import { EdgeConfigPlatformApiError } from '../types';
+
+function restoreFetch(original: typeof globalThis.fetch) {
+  globalThis.fetch = original;
+}
+
+describe('EdgeConfigPlatformClient', () => {
+  it('should require an API key', () => {
+    expect(() => new EdgeConfigPlatformClient({ apiKey: '' })).toThrow('API key is required');
+  });
+
+  it('should include Bearer Authorization header', async () => {
+    const originalFetch = globalThis.fetch;
+    let capturedHeaders: Record<string, string> = {};
+
+    globalThis.fetch = mock((_url: unknown, options: RequestInit) => {
+      capturedHeaders = options.headers as Record<string, string>;
+      return Promise.resolve(
+        new Response(JSON.stringify([]), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        })
+      );
+    }) as any;
+
+    const client = new EdgeConfigPlatformClient({ apiKey: 'test-token' });
+    await client.get('/v1/edge-config');
+
+    expect(capturedHeaders['Authorization']).toBe('Bearer test-token');
+    expect(capturedHeaders['Accept']).toBe('application/json');
+
+    restoreFetch(originalFetch);
+  });
+
+  it('should append teamId query parameter when configured', async () => {
+    const originalFetch = globalThis.fetch;
+    let capturedUrl = '';
+
+    globalThis.fetch = mock((url: unknown) => {
+      capturedUrl = String(url);
+      return Promise.resolve(
+        new Response(JSON.stringify([]), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        })
+      );
+    }) as any;
+
+    const client = new EdgeConfigPlatformClient({ apiKey: 'test-token', teamId: 'team_abc123' });
+    await client.get('/v1/edge-config');
+
+    expect(capturedUrl).toContain('teamId=team_abc123');
+    expect(capturedUrl).toContain('https://api.vercel.com/v1/edge-config');
+
+    restoreFetch(originalFetch);
+  });
+
+  it('should throw EdgeConfigPlatformApiError on non-ok response', async () => {
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = mock(() =>
+      Promise.resolve(
+        new Response(JSON.stringify({ error: { code: 'unauthorized', message: 'Not authorized' } }), {
+          status: 401,
+          headers: { 'content-type': 'application/json' },
+        })
+      )
+    ) as any;
+
+    const client = new EdgeConfigPlatformClient({ apiKey: 'bad-token' });
+
+    try {
+      await client.get('/v1/edge-config');
+      expect(true).toBe(false);
+    } catch (err) {
+      expect(err).toBeInstanceOf(EdgeConfigPlatformApiError);
+      expect((err as EdgeConfigPlatformApiError).statusCode).toBe(401);
+      expect((err as EdgeConfigPlatformApiError).message).toBe('Not authorized');
+    }
+
+    restoreFetch(originalFetch);
+  });
+
+  it('should handle 204 No Content', async () => {
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = mock(() => Promise.resolve(new Response(null, { status: 204 }))) as any;
+
+    const client = new EdgeConfigPlatformClient({ apiKey: 'test-token' });
+    const result = await client.delete('/v1/edge-config/ecfg_test');
+    expect(result).toEqual({});
+
+    restoreFetch(originalFetch);
+  });
+});
+
+describe('EdgeConfigPlatform', () => {
+  it('should PATCH items at /v1/edge-config/{id}/items', async () => {
+    const originalFetch = globalThis.fetch;
+    let capturedUrl = '';
+    let capturedMethod = '';
+    let capturedBody = '';
+
+    globalThis.fetch = mock((url: unknown, options: RequestInit) => {
+      capturedUrl = String(url);
+      capturedMethod = options.method || 'GET';
+      capturedBody = options.body as string;
+      return Promise.resolve(
+        new Response(JSON.stringify({ status: 'ok' }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        })
+      );
+    }) as any;
+
+    const api = new EdgeConfigPlatform({ apiKey: 'test-token', teamId: 'team_xyz' });
+    const result = await api.patchItems('ecfg_abc', {
+      items: [{ operation: 'upsert', key: 'feature_flag', value: true }],
+    });
+
+    expect(capturedMethod).toBe('PATCH');
+    expect(capturedUrl).toContain('/v1/edge-config/ecfg_abc/items');
+    expect(capturedUrl).toContain('teamId=team_xyz');
+    expect(JSON.parse(capturedBody)).toEqual({
+      items: [{ operation: 'upsert', key: 'feature_flag', value: true }],
+    });
+    expect(result).toEqual({ status: 'ok' });
+
+    restoreFetch(originalFetch);
+  });
+
+  it('should list edge configs at /v1/edge-config', async () => {
+    const originalFetch = globalThis.fetch;
+    let capturedUrl = '';
+
+    globalThis.fetch = mock((url: unknown) => {
+      capturedUrl = String(url);
+      return Promise.resolve(
+        new Response(JSON.stringify([{ id: 'ecfg_1', slug: 'my-config' }]), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        })
+      );
+    }) as any;
+
+    const api = new EdgeConfigPlatform({ apiKey: 'test-token' });
+    const result = await api.listEdgeConfigs();
+
+    expect(capturedUrl).toContain('https://api.vercel.com/v1/edge-config');
+    expect(result).toHaveLength(1);
+    expect(result[0]?.id).toBe('ecfg_1');
+    expect(result[0]?.slug).toBe('my-config');
+
+    restoreFetch(originalFetch);
+  });
+});