@hasna/connectors 0.4.0 → 0.4.2

package/connectors/connect-zendesk/scripts/publish.ts

@@ -0,0 +1,210 @@
+#!/usr/bin/env bun
+/**
+ * Auto-versioning publish script
+ * - Fetches current npm version
+ * - Auto-bumps patch version if local version <= npm version
+ * - Creates git tag
+ * - Publishes to npm
+ */
+
+import { $ } from 'bun';
+import { readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+interface PackageJson {
+  name: string;
+  version: string;
+  [key: string]: unknown;
+}
+
+type BumpType = 'patch' | 'minor' | 'major';
+
+function parseVersion(version: string): { major: number; minor: number; patch: number } {
+  const [major, minor, patch] = version.split('.').map(Number);
+  return { major, minor, patch };
+}
+
+function bumpVersion(version: string, type: BumpType = 'patch'): string {
+  const { major, minor, patch } = parseVersion(version);
+
+  switch (type) {
+    case 'major':
+      return `${major + 1}.0.0`;
+    case 'minor':
+      return `${major}.${minor + 1}.0`;
+    case 'patch':
+    default:
+      return `${major}.${minor}.${patch + 1}`;
+  }
+}
+
+function compareVersions(a: string, b: string): number {
+  const vA = parseVersion(a);
+  const vB = parseVersion(b);
+
+  if (vA.major !== vB.major) return vA.major - vB.major;
+  if (vA.minor !== vB.minor) return vA.minor - vB.minor;
+  return vA.patch - vB.patch;
+}
+
+async function getNpmVersion(packageName: string): Promise<string | null> {
+  try {
+    const result = await $`npm view ${packageName} version 2>/dev/null`.text();
+    return result.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+async function hasUncommittedChanges(): Promise<boolean> {
+  try {
+    const result = await $`git status --porcelain`.text();
+    return result.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+async function isGitRepo(): Promise<boolean> {
+  try {
+    await $`git rev-parse --git-dir 2>/dev/null`.text();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function createGitTag(version: string, packageName: string): Promise<boolean> {
+  const tagName = `${packageName}@${version}`;
+
+  try {
+    // Check if tag already exists
+    const existingTags = await $`git tag -l ${tagName}`.text();
+    if (existingTags.trim()) {
+      console.log(`⚠️  Tag ${tagName} already exists, skipping tag creation`);
+      return true;
+    }
+
+    await $`git tag -a ${tagName} -m "Release ${tagName}"`;
+    console.log(`✅ Created git tag: ${tagName}`);
+    return true;
+  } catch (error) {
+    console.error(`❌ Failed to create git tag: ${error}`);
+    return false;
+  }
+}
+
+async function commitVersionBump(version: string, packageName: string): Promise<boolean> {
+  try {
+    await $`git add package.json`;
+    await $`git commit -m "chore(${packageName}): bump version to ${version}"`;
+    console.log(`✅ Committed version bump`);
+    return true;
+  } catch (error) {
+    console.error(`❌ Failed to commit: ${error}`);
+    return false;
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const bumpType = (args.find(a => ['patch', 'minor', 'major'].includes(a)) || 'patch') as BumpType;
+  const skipGit = args.includes('--skip-git');
+  const dryRun = args.includes('--dry-run');
+  const force = args.includes('--force');
+
+  // Read package.json
+  const pkgPath = join(process.cwd(), 'package.json');
+  const pkg: PackageJson = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+
+  console.log(`\n📦 Publishing ${pkg.name}\n`);
+
+  // Get current npm version
+  const npmVersion = await getNpmVersion(pkg.name);
+  let newVersion = pkg.version;
+
+  if (npmVersion) {
+    console.log(`📌 Current npm version: ${npmVersion}`);
+    console.log(`📌 Local version: ${pkg.version}`);
+
+    // Check if we need to bump
+    if (compareVersions(pkg.version, npmVersion) <= 0) {
+      newVersion = bumpVersion(npmVersion, bumpType);
+      console.log(`🔄 Auto-bumping to: ${newVersion}`);
+    } else {
+      console.log(`✅ Local version is ahead, using: ${pkg.version}`);
+    }
+  } else {
+    console.log(`📌 Package not yet published to npm`);
+    console.log(`📌 Using local version: ${pkg.version}`);
+  }
+
+  // Update package.json if version changed
+  if (newVersion !== pkg.version) {
+    if (dryRun) {
+      console.log(`\n🧪 DRY RUN: Would update version to ${newVersion}`);
+    } else {
+      pkg.version = newVersion;
+      writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+      console.log(`✅ Updated package.json to version ${newVersion}`);
+    }
+  }
+
+  // Git operations
+  const isGit = await isGitRepo();
+
+  if (isGit && !skipGit) {
+    const hasChanges = await hasUncommittedChanges();
+
+    if (hasChanges && newVersion !== pkg.version) {
+      if (dryRun) {
+        console.log(`🧪 DRY RUN: Would commit version bump`);
+      } else {
+        await commitVersionBump(newVersion, pkg.name.replace('@hasna/', ''));
+      }
+    }
+
+    if (dryRun) {
+      console.log(`🧪 DRY RUN: Would create tag ${pkg.name}@${newVersion}`);
+    } else {
+      await createGitTag(newVersion, pkg.name.replace('@hasna/', ''));
+    }
+  }
+
+  // Build
+  console.log(`\n🔨 Building...`);
+  if (!dryRun) {
+    await $`bun run build`;
+  } else {
+    console.log(`🧪 DRY RUN: Would run build`);
+  }
+
+  // Publish
+  console.log(`\n🚀 Publishing to npm...`);
+  if (dryRun) {
+    console.log(`🧪 DRY RUN: Would publish ${pkg.name}@${newVersion}`);
+  } else {
+    try {
+      await $`npm publish`;
+      console.log(`\n✅ Successfully published ${pkg.name}@${newVersion}`);
+    } catch (error) {
+      console.error(`\n❌ Publish failed: ${error}`);
+      process.exit(1);
+    }
+  }
+
+  // Push tags
+  if (isGit && !skipGit && !dryRun) {
+    console.log(`\n📤 Pushing tags to remote...`);
+    try {
+      await $`git push --tags`;
+      console.log(`✅ Pushed tags to remote`);
+    } catch {
+      console.log(`⚠️  Could not push tags (no remote or not configured)`);
+    }
+  }
+
+  console.log(`\n✨ Done!\n`);
+}
+
+main().catch(console.error);

package/connectors/connect-zendesk/server/index.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/server/index.ts
+var PORT = parseInt(process.env.PORT || "3000");
+var HOST = process.env.HOST || "0.0.0.0";
+var API_KEY = process.env.CONNECTOR_API_KEY || "";
+if (!API_KEY) {
+  console.error("WARNING: CONNECTOR_API_KEY not set - server will reject all authenticated requests");
+}
+var startTime = Date.now();
+function getServerInfo() {
+  return {
+    name: "connect-zendesk",
+    version: "1.0.0",
+    uptime: Math.floor((Date.now() - startTime) / 1000),
+    timestamp: new Date().toISOString(),
+    environment: "development"
+  };
+}
+function jsonResponse(data, status = 200) {
+  return new Response(JSON.stringify(data, null, 2), {
+    status,
+    headers: {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+      "Access-Control-Allow-Headers": "Content-Type, Authorization, X-API-Key"
+    }
+  });
+}
+function handleCORS() {
+  return new Response(null, {
+    status: 204,
+    headers: {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+      "Access-Control-Allow-Headers": "Content-Type, Authorization, X-API-Key"
+    }
+  });
+}
+function validateApiKey(req) {
+  const apiKey = req.headers.get("X-API-Key");
+  return apiKey === API_KEY && API_KEY !== "";
+}
+var server = Bun.serve({
+  port: PORT,
+  hostname: HOST,
+  async fetch(req) {
+    const url = new URL(req.url);
+    const path = url.pathname;
+    if (req.method === "OPTIONS") {
+      return handleCORS();
+    }
+    if (path === "/health" || path === "/zendesk/health") {
+      return jsonResponse({ status: "healthy" });
+    }
+    if (!validateApiKey(req)) {
+      return jsonResponse({
+        error: "Unauthorized",
+        code: "INVALID_API_KEY",
+        hint: "Provide valid API key via X-API-Key header"
+      }, 401);
+    }
+    if (path === "/status" || path === "/zendesk/status") {
+      return jsonResponse({
+        status: "ok",
+        service: "connect-zendesk",
+        ...getServerInfo(),
+        endpoints: {
+          health: "/zendesk/health",
+          status: "/zendesk/status",
+          api: "/zendesk/api/*"
+        }
+      });
+    }
+    if (path === "/" || path === "/zendesk" || path === "/zendesk/") {
+      return jsonResponse({
+        service: "connect-zendesk",
+        description: "Zendesk API connector service",
+        version: "1.0.0",
+        documentation: "https://github.com/hasna/connect-zendesk",
+        endpoints: {
+          health: "GET /zendesk/health (no auth)",
+          status: "GET /zendesk/status (requires X-API-Key)",
+          api: "See Zendesk API documentation (requires X-API-Key)"
+        }
+      });
+    }
+    if (path.startsWith("/zendesk/api/") || path.startsWith("/api/")) {
+      const authHeader = req.headers.get("Authorization");
+      if (!authHeader) {
+        return jsonResponse({ error: "Authorization header required for Zendesk API", code: "ZENDESK_AUTH_REQUIRED" }, 401);
+      }
+      const subdomain = url.searchParams.get("subdomain") || req.headers.get("X-Zendesk-Subdomain");
+      if (!subdomain) {
+        return jsonResponse({
+          error: "Zendesk subdomain required",
+          code: "MISSING_SUBDOMAIN",
+          hint: "Provide subdomain via query param (?subdomain=xxx) or X-Zendesk-Subdomain header"
+        }, 400);
+      }
+      const apiPath = path.replace("/zendesk/api/", "").replace("/api/", "");
+      const zendeskUrl = `https://${subdomain}.zendesk.com/api/v2/${apiPath}${url.search}`;
+      try {
+        const response = await fetch(zendeskUrl, {
+          method: req.method,
+          headers: {
+            Authorization: authHeader,
+            "Content-Type": "application/json",
+            Accept: "application/json"
+          },
+          body: req.method !== "GET" && req.method !== "HEAD" ? await req.text() : undefined
+        });
+        const data = await response.json();
+        return jsonResponse(data, response.status);
+      } catch (err) {
+        return jsonResponse({
+          error: "Failed to proxy request to Zendesk",
+          code: "PROXY_ERROR",
+          details: String(err)
+        }, 502);
+      }
+    }
+    return jsonResponse({
+      error: "Not found",
+      code: "NOT_FOUND",
+      path
+    }, 404);
+  },
+  error(error) {
+    console.error("Server error:", error);
+    return jsonResponse({ error: "Internal server error", code: "INTERNAL_ERROR" }, 500);
+  }
+});
+console.log(`\uD83D\uDE80 connect-zendesk server running at http://${HOST}:${PORT}`);
+console.log(`   Health: http://${HOST}:${PORT}/zendesk/health (no auth)`);
+console.log(`   Status: http://${HOST}:${PORT}/zendesk/status (requires X-API-Key)`);
+console.log(`   API Key configured: ${API_KEY ? "Yes" : "No"}`);
+export {
+  server
+};

package/connectors/connect-zendesk/src/api/automations.ts

@@ -0,0 +1,95 @@
+import type { ZendeskClient } from './client';
+import type {
+  ZendeskAutomation,
+  ZendeskAutomationResponse,
+  ZendeskAutomationsResponse,
+  CreateAutomationRequest,
+  UpdateAutomationRequest,
+  AutomationListParams,
+} from '../types';
+
+/**
+ * Zendesk Automations API
+ * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/automations/
+ */
+export class AutomationsApi {
+  constructor(private readonly client: ZendeskClient) {}
+
+  /**
+   * List all automations
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/automations/#list-automations
+   */
+  async list(params?: AutomationListParams): Promise<ZendeskAutomation[]> {
+    const response = await this.client.get<ZendeskAutomationsResponse>('/automations.json', {
+      page: params?.page,
+      per_page: params?.per_page,
+      active: params?.active,
+      sort_by: params?.sort_by,
+      sort_order: params?.sort_order,
+    });
+    return response.automations;
+  }
+
+  /**
+   * List active automations
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/automations/#list-active-automations
+   */
+  async listActive(params?: AutomationListParams): Promise<ZendeskAutomation[]> {
+    const response = await this.client.get<ZendeskAutomationsResponse>('/automations/active.json', {
+      page: params?.page,
+      per_page: params?.per_page,
+      sort_by: params?.sort_by,
+      sort_order: params?.sort_order,
+    });
+    return response.automations;
+  }
+
+  /**
+   * Get an automation by ID
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/automations/#show-automation
+   */
+  async get(automationId: number): Promise<ZendeskAutomation> {
+    const response = await this.client.get<ZendeskAutomationResponse>(`/automations/${automationId}.json`);
+    return response.automation;
+  }
+
+  /**
+   * Create a new automation
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/automations/#create-automation
+   */
+  async create(data: CreateAutomationRequest): Promise<ZendeskAutomation> {
+    const response = await this.client.post<ZendeskAutomationResponse>('/automations.json', data);
+    return response.automation;
+  }
+
+  /**
+   * Update an automation
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/automations/#update-automation
+   */
+  async update(automationId: number, data: UpdateAutomationRequest): Promise<ZendeskAutomation> {
+    const response = await this.client.put<ZendeskAutomationResponse>(`/automations/${automationId}.json`, data);
+    return response.automation;
+  }
+
+  /**
+   * Delete an automation
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/automations/#delete-automation
+   */
+  async delete(automationId: number): Promise<void> {
+    await this.client.delete(`/automations/${automationId}.json`);
+  }
+
+  /**
+   * Search automations by title
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/automations/#search-automations
+   */
+  async search(query: string, params?: AutomationListParams): Promise<ZendeskAutomation[]> {
+    const response = await this.client.get<ZendeskAutomationsResponse>('/automations/search.json', {
+      query,
+      page: params?.page,
+      per_page: params?.per_page,
+      active: params?.active,
+    });
+    return response.automations;
+  }
+}

package/connectors/connect-zendesk/src/api/brands.ts

@@ -0,0 +1,80 @@
+import type { ZendeskClient } from './client';
+import type {
+  ZendeskBrand,
+  ZendeskBrandResponse,
+  ZendeskBrandsResponse,
+  CreateBrandRequest,
+  UpdateBrandRequest,
+  BrandListParams,
+} from '../types';
+
+/**
+ * Zendesk Brands API
+ * @see https://developer.zendesk.com/api-reference/ticketing/account-configuration/brands/
+ */
+export class BrandsApi {
+  constructor(private readonly client: ZendeskClient) {}
+
+  /**
+   * List all brands
+   * @see https://developer.zendesk.com/api-reference/ticketing/account-configuration/brands/#list-brands
+   */
+  async list(params?: BrandListParams): Promise<ZendeskBrand[]> {
+    const response = await this.client.get<ZendeskBrandsResponse>('/brands.json', {
+      page: params?.page,
+      per_page: params?.per_page,
+    });
+    return response.brands;
+  }
+
+  /**
+   * Get a brand by ID
+   * @see https://developer.zendesk.com/api-reference/ticketing/account-configuration/brands/#show-brand
+   */
+  async get(brandId: number): Promise<ZendeskBrand> {
+    const response = await this.client.get<ZendeskBrandResponse>(`/brands/${brandId}.json`);
+    return response.brand;
+  }
+
+  /**
+   * Create a new brand
+   * @see https://developer.zendesk.com/api-reference/ticketing/account-configuration/brands/#create-brand
+   */
+  async create(data: CreateBrandRequest): Promise<ZendeskBrand> {
+    const response = await this.client.post<ZendeskBrandResponse>('/brands.json', data);
+    return response.brand;
+  }
+
+  /**
+   * Update a brand
+   * @see https://developer.zendesk.com/api-reference/ticketing/account-configuration/brands/#update-brand
+   */
+  async update(brandId: number, data: UpdateBrandRequest): Promise<ZendeskBrand> {
+    const response = await this.client.put<ZendeskBrandResponse>(`/brands/${brandId}.json`, data);
+    return response.brand;
+  }
+
+  /**
+   * Delete a brand
+   * @see https://developer.zendesk.com/api-reference/ticketing/account-configuration/brands/#delete-brand
+   */
+  async delete(brandId: number): Promise<void> {
+    await this.client.delete(`/brands/${brandId}.json`);
+  }
+
+  /**
+   * Check host mapping validity
+   * @see https://developer.zendesk.com/api-reference/ticketing/account-configuration/brands/#check-host-mapping-validity-for-an-existing-brand
+   */
+  async checkHostMapping(brandId: number): Promise<{ is_valid: boolean; reason: string | null }> {
+    return this.client.get(`/brands/${brandId}/check_host_mapping.json`);
+  }
+
+  /**
+   * Check host mapping validity (before creating)
+   * @see https://developer.zendesk.com/api-reference/ticketing/account-configuration/brands/#check-host-mapping-validity
+   */
+  async checkHostMappingForHost(hostMapping: string, subdomain: string): Promise<{ is_valid: boolean; reason: string | null }> {
+    return this.client.get('/brands/check_host_mapping.json', { host_mapping: hostMapping, subdomain });
+  }
+}