Organizations & Org Family

async function projectsForChildOrg(orgSlug) {
  const params = new URLSearchParams({ org_slug: orgSlug });
  return paginate(`https://api.vomo.org/v1/projects?${params}`);
}

async function campaignsForChildOrg(orgSlug) {
  const params = new URLSearchParams({ org_slug: orgSlug });
  return paginate(`https://api.vomo.org/v1/campaigns?${params}`);
}

curl https://api.vomo.org/v1/organizations \
  -H "Authorization: Bearer $VOMO_API_TOKEN"

async function getOrganizationFamily() {
  const response = await fetch(
    'https://api.vomo.org/v1/organizations',
    { headers: { Authorization: `Bearer ${token}` } }
  );

  if (!response.ok) throw new Error(`Failed: ${response.status}`);

  const result = await response.json();
  return result.data;
}

curl https://api.vomo.org/v1/organizations/12345 \
  -H "Authorization: Bearer $VOMO_API_TOKEN"

async function getOrganization(orgId) {
  const response = await fetch(
    `https://api.vomo.org/v1/organizations/${orgId}`,
    { headers: { Authorization: `Bearer ${token}` } }
  );

  if (response.status === 404) return null;
  if (!response.ok) throw new Error(`Failed: ${response.status}`);

  const result = await response.json();
  return parseOrganization(result.data);
}

async function buildOrgRoutingMap() {
  const family = await getOrganizationFamily();
  const routingMap = new Map();

  // Map by slug for easy lookup
  function mapOrg(org) {
    routingMap.set(org.slug, {
      id: org.id,
      name: org.name,
      slug: org.slug,
      monikers: {
        groups: org.groups_moniker,
        project: org.project_moniker,
        campaign: org.campaign_moniker,
      },
    });

    for (const child of org.child_organizations ?? []) {
      mapOrg(child);
    }
  }

  mapOrg(family);
  return routingMap;
}

// Usage
const routingMap = await buildOrgRoutingMap();
const orgInfo = routingMap.get('gotham-food-bank');

function getOrgLabel(org, kind) {
  switch (kind) {
    case 'group':
      return org.groups_moniker ?? 'Group';
    case 'project':
      return org.project_moniker ?? 'Project';
    case 'campaign':
      return org.campaign_moniker ?? 'Campaign';
    default:
      return capitalize(kind);
  }
}

// Usage
const projectLabel = getOrgLabel(currentOrg, 'project');
// e.g., "Event" for orgs that customize

// Aggregate across the entire family (default token scope)
async function totalActiveProjectsAcrossFamily() {
  const params = new URLSearchParams({ active: 'true', published: 'true' });
  const all = await paginate(`https://api.vomo.org/v1/projects?${params}`);
  return all.length;
}

// Filter to one specific org
async function activeProjectsForOrg(orgSlug) {
  const params = new URLSearchParams({
    active: 'true',
    published: 'true',
    org_slug: orgSlug,
  });
  return paginate(`https://api.vomo.org/v1/projects?${params}`);
}

// Filter to multiple specific orgs
async function activeProjectsForOrgs(orgSlugs) {
  const params = new URLSearchParams({
    active: 'true',
    published: 'true',
    org_slug: orgSlugs.join(','),
  });
  return paginate(`https://api.vomo.org/v1/projects?${params}`);
}

async function getHomeOrganization() {
  const family = await getOrganizationFamily();
  // If the family response returns a single Organization, that's the home
  // If it returns a hierarchy, the root (no parent_organizations) is the home
  if (Array.isArray(family.parent_organizations) && family.parent_organizations.length === 0) {
    return family;
  }
  // ...otherwise navigate up to the topmost org
  return family;
}

class VomoOrganizations {
  constructor({ token }) {
    this.token = token;
    this.baseUrl = 'https://api.vomo.org/v1';
  }

  async getFamily() {
    const response = await this._fetch(`${this.baseUrl}/organizations`);
    if (!response.ok) throw new Error(`Failed: ${response.status}`);
    const result = await response.json();
    return this._parseOrg(result.data);
  }

  async getById(orgId) {
    const response = await this._fetch(`${this.baseUrl}/organizations/${orgId}`);
    if (response.status === 404) return null;
    if (!response.ok) throw new Error(`Failed: ${response.status}`);
    const result = await response.json();
    return this._parseOrg(result.data);
  }

  _fetch(url, options = {}) {
    return fetch(url, {
      ...options,
      headers: {
        Authorization: `Bearer ${this.token}`,
        Accept: 'application/json',
        ...options.headers,
      },
    });
  }

  _parseOrg(raw) {
    return {
      id: raw.id,
      name: raw.name,
      slug: raw.slug,
      type: raw.type,
      description: raw.description ?? null,
      email: raw.email,
      phone: raw.phone,
      website: raw.website,
      taxNumber: raw.tax_number ?? null,
      orgSize: raw.org_size,
      backgroundCheckExpiration: raw.background_check_expiration,
      hubExperience: raw.hub_experience,
      invitationToken: raw.invitation_token,
      address: raw.address ?? null,
      logo: raw.logo ? this._parseLogo(raw.logo) : null,
      monikers: {
        groups: raw.groups_moniker ?? 'Group',
        project: raw.project_moniker ?? 'Project',
        campaign: raw.campaign_moniker ?? 'Campaign',
      },
      createdAt: raw.created_at ? new Date(raw.created_at) : null,
      updatedAt: raw.updated_at ? new Date(raw.updated_at) : null,
      deletedAt: raw.deleted_at ? new Date(raw.deleted_at) : null,
      childOrganizations: (raw.child_organizations ?? []).map(this._parseOrg.bind(this)),
      parentOrganizations: (raw.parent_organizations ?? []).map(this._parseOrg.bind(this)),
    };
  }

  _parseLogo(raw) {
    return {
      id: raw.id,
      type: raw.type,
      urls: raw.urls ?? {},
      mediableId: raw.mediable_id,
      mediableType: raw.mediable_type,
    };
  }
}