src/

import * as App from '@zaius/app-sdk';
import {logger, storage} from '@zaius/app-sdk';

export class Lifecycle extends App.Lifecycle {
  public async onInstall(): Promise<App.LifecycleResult> {
    try {
      logger.info(`Performing Install`);
      // TODO: any operation you need to perform during installation
      return {success: true};
    } catch (error) {
      logger.error('Error during installation:', error);
      return {success: false, retryable: true};
    }
  }

  public async onSetingsForm(page: string, action: string, formData: App.ValueHash): Promise<App.Response> {
    try {
      // TODO: any logic you need to perform when a setup form section is submitted
      // When you are finished, save the form data to the settings store
      storage.settings.put(page, formData);
      return new App.Response(200);
    } catch (e) {
      return new App.Response(500);
    }
  }

  public async onUpgrade(fromVersion: string): Promise<App.LifecycleResult> {
    // TODO: any logic required when upgrading from a previous version of the app
    // Note: `fromVersion` may not be the most recent version or could be a beta version
    return {success: true};
  }

  public async onFinalizeUpgrade(fromVersion: string): Promise<App.LifecycleResult> {
    // TODO: any logic required when finalizing an upgrade from a previous version
    // At this point, new webhook URLs have been created for any new functions in this version
    return {success: true};
  }

  public async onUninstall(): Promise<App.LifecycleResult> {
    // TODO: any logic required to properly uninstall the app
    return {success: true};
  }
}

functions:
  get_esp_lists: #<-- name used for form sources and reference within the app
    entry_point: GetEspLists #<-- File and Class name
    description: Pulls the lists from the ESP to select which ones you want imported

import * as App from '@zaius/app-sdk';
import {logger} from '@zaius/app-sdk';
import {z} from '@zaius/node-sdk';

/**
 * Returns the lists within ODP
 */
export class GetEspLists extends App.Function {

  public async perform(): Promise<App.Response> {
      try {
        return new App.Response(200, await z.lists.getLists().data);
      } catch (e) {
        logger.error(e);
        return new App.Response(500, `An unexpected error occurred: ${e}`);
      }
    }
  }
}

jobs:
  historical_import: #<-- used to reference within app
    entry_point: Import #<-- File/Class name
    description: Performs a one-time historical import when triggered

import * as App from '@zaius/app-sdk';
import {logger, ValueHash} from '@zaius/app-sdk';

interface ImportJobStatus extends App.JobStatus {
  state: {
    // TODO: define your job state here
  };
}

/**
 * Performs an import
 */
export class Import extends App.Job {

  /**
   * Prepares to run a job. Prepare is called at the start of a job
   * and again only if the job was interrupted and is being resumed.
   * Use this function to read secrets and establish connections to simplify the job loop (perform).
   * @param params a hash if params were supplied to the job run, otherwise an empty hash
   * @param status if job was interrupted and should continue from the last known state
   */
  public async prepare(params: ValueHash, status?: ImportJobStatus): Promise<ImportJobStatus> {
    logger.info('Preparing Import Job with params:', params, 'and status', status);
    // TODO: Prepare for a job run
    return {state: {}, complete: false};
  }

  /**
   * Performs a unit of work. Jobs should perform a small unit of work and then return the current state.
   * Perform is called in a loop where the previously returned state will be given to the next iteration.
   * Iteration will continue until the returned state.complete is set to true or the job is interrupted.
   * @param status last known job state and status
   * @returns The current JobStatus/state that you can use to perform the next iteration or resume a job if interrupted.
   */
  public async perform(status: ImportJobStatus): Promise<ImportJobStatus> {
    // TODO: perform a small unit of work, then return your state

    // When you are finished, set complete to true
    status.complete = true;

    // Return your status. If complete is false, perform will be called again imediately with the status you returned
    return status;
  }
}