index.js

const core = require('@actions/core');
const https = require('https');

async function makeRequest(options, data) {
  return new Promise((resolve, reject) => {
    const req = https.request(options, (res) => {
      let body = '';
      res.on('data', chunk => body += chunk);
      res.on('end', () => {
        try {
          resolve({
            statusCode: res.statusCode,
            body: body ? JSON.parse(body) : null
          });
        } catch (e) {
          resolve({
            statusCode: res.statusCode,
            body: body
          });
        }
      });
    });
    
    req.on('error', reject);
    
    if (data) {
      req.write(JSON.stringify(data));
    }
    req.end();
  });
}

async function updateEphemeralDatabase(apiHost, apiKey, databaseEntityId, payload) {
  const url = new URL(`/api/database/${databaseEntityId}`, apiHost);
  core.info(`Updating ephemeral database at url ${url}`);

  // Get version from package.json
  const version = require('./package.json').version;

  const options = {
    hostname: url.hostname,
    port: url.port || 443,
    path: url.pathname,
    method: 'PUT',
    headers: {
      'Authorization': `apikey ${apiKey}`,
      'Content-Type': 'application/json',
      'User-Agent': 'Tonic-Github-Action',
      'X-GitHub-Action': 'update-ephemeral-database',
      'X-GitHub-Action-Version': version
    }
  };

  const response = await makeRequest(options, payload);
  if (response.statusCode >= 400) {
    throw new Error(`HTTP ${response.statusCode}: ${JSON.stringify(response.body)}`);
  }

  return response.body;
}

function buildExpiryConfig(expiryMode, inputs) {
  switch (expiryMode.toLowerCase()) {
    case 'static': {
      const expiryMinutes = parseInt(inputs.expiryMinutes);
      if (!expiryMinutes || expiryMinutes <= 0) {
        throw new Error('expiry-minutes is required and must be positive for static expiry mode');
      }
      return {
        expiryType: 'Static',
        durationEnd: {
          minutesFromStartToExpiry: expiryMinutes,
          minutesFromLastActivityToExpiry: 60
        }
      };
    }

    case 'inactivity': {
      const inactivityMinutes = parseInt(inputs.inactivityMinutes);
      if (!inactivityMinutes || inactivityMinutes <= 0) {
        throw new Error('inactivity-minutes is required and must be positive for inactivity expiry mode');
      }
      return {
        expiryType: 'Inactivity',
        durationEnd: {
          minutesFromStartToExpiry: 0,
          minutesFromLastActivityToExpiry: inactivityMinutes
        }
      };
    }

    case 'business-hours': {
      return {
        expiryType: 'BusinessHours',
        businessHoursEnd: {
          timeZone: inputs.businessHoursTimezone,
          startDayName: inputs.businessHoursStartDay,
          endDayName: inputs.businessHoursEndDay,
          startHour: parseInt(inputs.businessHoursStartHour),
          endHour: parseInt(inputs.businessHoursEndHour)
        }
      };
    }

    case 'never':
      return null;

    default:
      throw new Error(`Invalid expiry-mode: ${expiryMode}. Must be one of: static, inactivity, business-hours, never`);
  }
}

async function run() {
  try {
    const apiHost = core.getInput('ephemeral-url');
    const apiKey = core.getInput('ephemeral-api-key');
    const databaseEntityId = core.getInput('database-entity-id');
    const ephemeralEntityName = core.getInput('entity-name');
    const databaseDescription = core.getInput('database-description');
    const expiryMode = core.getInput('expiry-mode') || 'never';

    const payload = {
      name: ephemeralEntityName,
      databaseDescription: databaseDescription
    };

    // Build expiry configuration based on mode
    const expiryConfig = buildExpiryConfig(expiryMode, {
      expiryMinutes: core.getInput('expiry-minutes'),
      inactivityMinutes: core.getInput('inactivity-minutes'),
      businessHoursTimezone: core.getInput('business-hours-timezone'),
      businessHoursStartDay: core.getInput('business-hours-start-day'),
      businessHoursEndDay: core.getInput('business-hours-end-day'),
      businessHoursStartHour: core.getInput('business-hours-start-hour'),
      businessHoursEndHour: core.getInput('business-hours-end-hour')
    });

    if (expiryConfig) {
      payload.expiry = expiryConfig;
    }

    core.info(`Updating ephemeral database ${databaseEntityId} with expiry mode: ${expiryMode}`);
    core.info(`Payload: ${JSON.stringify(payload, null, 2)}`);

    const result = await updateEphemeralDatabase(apiHost, apiKey, databaseEntityId, payload);

    core.info(`Ephemeral database updated successfully: ${JSON.stringify(result)}`);

  } catch (error) {
    core.setFailed(`Failed to update ephemeral database: ${error.message}`);
  }
}

run();