Forms & Form Completions

function parseFieldValue(field, response) {
  switch (field.field_type) {
    case 'SHORTTEXT':
    case 'LONGTEXT':
    case 'TEXTSINGLE':
      return response.value; // String as-is
    case 'WAIVER':
      return response.value === 'true' || response.value === '1';
    case 'DROPDOWN':
      // Look up the option by value
      return field.options?.find((o) => o.value === response.value)?.name ?? response.value;
    case 'MULTIPLESELECT':
      // Comma-separated values; look up each
      const values = response.value.split(',').map((v) => v.trim());
      return values.map((v) =>
        field.options?.find((o) => o.value === v)?.name ?? v
      );
    default:
      return response.value; // Unknown type — return raw string
  }
}

curl "https://api.vomo.org/v1/forms?name_like=waiver&include_archived=false" \
  -H "Authorization: Bearer $VOMO_API_TOKEN"

async function activeForms() {
  return paginate('https://api.vomo.org/v1/forms?include_archived=false');
}

async function findFormsLike(searchTerm) {
  const params = new URLSearchParams({ name_like: searchTerm });
  return paginate(`https://api.vomo.org/v1/forms?${params}`);
}

async function recentlyUpdatedForms(sinceDate) {
  const params = new URLSearchParams({
    updated_after: sinceDate.toISOString(),
  });
  return paginate(`https://api.vomo.org/v1/forms?${params}`);
}

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

async function userCompletionsForForm(formId, userId) {
  const params = new URLSearchParams({ user_id: userId.toString() });
  return paginate(`https://api.vomo.org/v1/forms/${formId}/completions?${params}`);
}

async function newCompletionsForForm(formId, since) {
  const params = new URLSearchParams({
    created_after: since.toISOString(),
  });
  return paginate(`https://api.vomo.org/v1/forms/${formId}/completions?${params}`);
}

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

async function getFormCompletion(formId, completionId) {
  const response = await fetch(
    `https://api.vomo.org/v1/forms/${formId}/completions/${completionId}`,
    { 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 result.data;
}

async function getCompletionWithFieldContext(formId, completionId) {
  // 1. Fetch the Form (to get Field definitions)
  const forms = await fetch(`https://api.vomo.org/v1/forms?name_like=`, {
    headers: { Authorization: `Bearer ${token}` },
  });
  // ... find the specific form
  const form = (await forms.json()).data.find((f) => f.id === formId);

  // 2. Fetch the Completion
  const completion = await getFormCompletion(formId, completionId);
  if (!completion) return null;

  // 3. Join responses with field definitions
  const fieldsById = new Map(form.fields.map((f) => [f.id, f]));

  return {
    completionId: completion.id,
    user_id: completion.user_id,
    project_id: completion.project_id,
    submittedAt: new Date(completion.created_at),
    fields: completion.field_responses.map((r) => {
      const field = fieldsById.get(r.field_id);
      return {
        question: field?.name ?? `Field ${r.field_id}`,
        type: field?.field_type ?? 'UNKNOWN',
        value: parseFieldValue(field, r),
      };
    }),
  };
}

async function syncFormCompletions(customerId, formId) {
  const lastSync = await getCheckpoint(customerId, `form_${formId}`);

  const params = new URLSearchParams({
    created_after: lastSync.toISOString(),
  });

  let url = `https://api.vomo.org/v1/forms/${formId}/completions?${params}`;
  while (url) {
    const page = await fetchPage(url);
    for (const completion of page.data) {
      await externalSystem.recordFormCompletion({
        externalId: `vomo-form-${completion.id}`,
        formId: completion.form_id,
        userId: completion.user_id,
        projectId: completion.project_id,
        submittedAt: new Date(completion.created_at),
        responses: completion.field_responses,
      });
    }
    url = page.links.next;
  }

  await advanceCheckpoint(customerId, `form_${formId}`, new Date());
}

async function userFormHistory(userId) {
  // 1. Get all Forms (to know what's available)
  const forms = await activeForms();

  // 2. For each Form, get this user's completions
  const allCompletions = [];
  for (const form of forms) {
    const params = new URLSearchParams({ user_id: userId.toString() });
    const url = `https://api.vomo.org/v1/forms/${form.id}/completions?${params}`;
    const response = await fetch(url, { headers: { Authorization: `Bearer ${token}` } });
    const result = await response.json();

    for (const completion of result.data) {
      allCompletions.push({
        formName: form.name,
        formId: form.id,
        completion,
      });
    }
  }

  return allCompletions.sort((a, b) =>
    new Date(b.completion.created_at) - new Date(a.completion.created_at)
  );
}

async function findUsersNeedingWaiver(waiverFormId) {
  const oneYearAgo = new Date();
  oneYearAgo.setFullYear(oneYearAgo.getFullYear() - 1);

  // 1. Get all completions of the waiver
  const allCompletions = await paginate(
    `https://api.vomo.org/v1/forms/${waiverFormId}/completions`
  );

  // 2. Find the most recent completion per user
  const latestByUser = new Map();
  for (const c of allCompletions) {
    const existing = latestByUser.get(c.user_id);
    if (!existing || new Date(c.created_at) > new Date(existing.created_at)) {
      latestByUser.set(c.user_id, c);
    }
  }

  // 3. Filter to users whose latest is older than a year
  return Array.from(latestByUser.entries())
    .filter(([_, c]) => new Date(c.created_at) < oneYearAgo)
    .map(([userId, c]) => ({ userId, lastCompletedAt: c.created_at }));
}

async function aggregateFormResponses(formId) {
  const form = await getFormDetail(formId);
  const completions = await paginate(`https://api.vomo.org/v1/forms/${formId}/completions`);

  const aggregateByField = new Map();

  for (const completion of completions) {
    for (const response of completion.field_responses) {
      if (!aggregateByField.has(response.field_id)) {
        aggregateByField.set(response.field_id, {
          field: form.fields.find((f) => f.id === response.field_id),
          values: [],
        });
      }
      aggregateByField.get(response.field_id).values.push(response.value);
    }
  }

  // Format the aggregates per field type
  return Array.from(aggregateByField.entries()).map(([fieldId, data]) => ({
    fieldId,
    question: data.field?.name,
    type: data.field?.field_type,
    distribution: tallyDistribution(data.values, data.field),
  }));
}

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

  async list(filters = {}) {
    const params = new URLSearchParams(filters);
    const forms = [];
    let url = `${this.baseUrl}/forms?${params}`;

    while (url) {
      const response = await this._fetch(url);
      const page = await response.json();
      forms.push(...page.data.map(this._parseForm));
      url = page.links.next;
    }
    return forms;
  }

  async getCompletions(formId, filters = {}) {
    const params = new URLSearchParams(filters);
    const completions = [];
    let url = `${this.baseUrl}/forms/${formId}/completions?${params}`;

    while (url) {
      const response = await this._fetch(url);
      const page = await response.json();
      completions.push(...page.data.map(this._parseCompletion));
      url = page.links.next;
    }
    return completions;
  }

  async getCompletion(formId, completionId) {
    const response = await this._fetch(
      `${this.baseUrl}/forms/${formId}/completions/${completionId}`
    );
    if (response.status === 404) return null;
    if (!response.ok) throw new Error(`Failed: ${response.status}`);
    const result = await response.json();
    return this._parseCompletion(result.data);
  }

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

  _parseForm(raw) {
    return {
      id: raw.id,
      name: raw.name,
      description: raw.description ?? '',
      formType: raw.form_type,
      slug: raw.slug, // Treat as UUID per the example, not the misleading enum
      authorId: raw.author_id,
      organizationId: raw.organization_id,
      fields: (raw.fields ?? []).map(this._parseField),
      createdAt: new Date(raw.created_at),
      updatedAt: new Date(raw.updated_at),
      deletedAt: raw.deleted_at ? new Date(raw.deleted_at) : null,
    };
  }

  _parseField(raw) {
    return {
      id: raw.id,
      name: raw.name,
      description: raw.description ?? '',
      fieldType: raw.field_type,
      slug: raw.slug,
      showInProfile: raw.show_in_profile ?? false,
      options: (raw.options ?? []).map(this._parseOption),
    };
  }

  _parseOption(raw) {
    return {
      id: raw.id,
      name: raw.name,
      value: raw.value,
      enabled: raw.enabled ?? true,
      weight: raw.weight ?? 0,
    };
  }

  _parseCompletion(raw) {
    return {
      id: raw.id,
      formId: raw.form_id,
      userId: raw.user_id,
      projectId: raw.project_id ?? null,
      fieldResponses: (raw.field_responses ?? []).map(this._parseFieldResponse),
      createdAt: new Date(raw.created_at),
      updatedAt: new Date(raw.updated_at),
    };
  }

  _parseFieldResponse(raw) {
    return {
      id: raw.id,
      formCompletionId: raw.form_completion_id,
      userId: raw.user_id,
      fieldId: raw.field_id,
      value: raw.value,
    };
  }
}