import { Deepline } from 'deepline';

const ctx = await Deepline.connect();

const job = await ctx.play('prebuilt/person-linkedin-to-email').run({
  linkedin_url: 'https://www.linkedin.com/in/example-person/',
  first_name: 'Jane',
  last_name: 'Smith',
  company_name: 'ExampleCo',
  domain: 'example.com',
});

const result = await job.get();
console.log(JSON.stringify(result, null, 2));

import { definePlay } from 'deepline';

type Input = {
  domain: string;
};

type Output = {
  domain: string;
  lookupStatus: string;
};

export default definePlay(
  'docs-company-lookup',
  async (ctx, input: Input): Promise<Output> => {
    const result = await ctx.tools.execute({
      id: 'company_lookup',
      tool: 'test_rate_limit',
      input: {
        key: input.domain,
      },
      description:
        'Check that the company lookup path can run for this domain.',
    });

    return {
      domain: input.domain,
      lookupStatus: result.status,
    };
  },
);

import { definePlay } from 'deepline';

type Account = {
  domain: string;
  owner: string;
};

export default definePlay(
  'docs-nightly-account-refresh',
  async (ctx, input: { accounts: Account[] }) => {
    const rows = await ctx
      .dataset('account_refresh', input.accounts)
      .withColumn(
        'company_signal',
        (account, rowCtx) =>
          rowCtx.tools.execute({
            id: 'company_signal',
            tool: 'test_rate_limit',
            input: {
              key: account.domain,
            },
            description: 'Refresh one account signal for the owner.',
          }),
        { staleAfterSeconds: 86_400 },
      )
      .run({
        key: 'domain',
        description: 'Refresh target account signals once per day.',
      });

    return { rows };
  },
  {
    cron: {
      schedule: '0 9 * * *',
      timezone: 'America/New_York',
    },
    billing: {
      maxCreditsPerRun: 25,
    },
  },
);

import { definePlay } from 'deepline';

type InboundLead = {
  email: string;
  company_domain?: string;
  source?: string;
};

export default definePlay(
  'docs-inbound-lead-webhook',
  async (ctx, input: InboundLead) => {
    const domain = input.company_domain ?? input.email.split('@')[1] ?? '';
    const company = await ctx.tools.execute({
      id: 'company_context',
      tool: 'test_rate_limit',
      input: {
        key: domain,
      },
      description: 'Add company context before routing the inbound lead.',
    });

    return {
      email: input.email,
      domain,
      source: input.source ?? 'webhook',
      company_status: company.status,
    };
  },
  {
    webhook: {
      hmac: {
        secretEnv: 'HUBSPOT_WEBHOOK_SECRET',
        header: 'x-hubspot-signature-v3',
        algorithm: 'sha256',
      },
    },
  },
);

withColumn<Name extends string, Value>(
    name: Name,
    resolver: ColumnResolver<OutputRow, Value>,
  ): DatasetBuilder<InputRow, OutputRow & Record<Name, Value>>;

withColumn<Name extends string, Value>(
    name: Name,
    definition: DatasetColumnDefinition<OutputRow, Value> & {
      readonly runIf: (
        row: OutputRow,
        index: number,
      ) => boolean | Promise<boolean>;
    },
  ): DatasetBuilder<InputRow, OutputRow & Record<Name, Value | null>>;

withColumn<Name extends string, Value>(
    name: Name,
    definition: DatasetColumnDefinition<OutputRow, Value>,
  ): DatasetBuilder<InputRow, OutputRow & Record<Name, Value>>;

withColumn<Name extends string, Value>(
    name: Name,
    resolver:
      | StepResolver<OutputRow, Value>
      | StepProgramResolver<OutputRow, Value>,
    options: StepOptions<OutputRow, Value>,
  ): DatasetBuilder<InputRow, OutputRow & Record<Name, Value | null>>;

run(options?: {
    description?: string;
    key?:
      | (keyof InputRow & string)
      | readonly (keyof InputRow & string)[]
      | ((
          row: InputRow,
          index: number,
        ) => string | number | readonly unknown[]);
  }): Promise<PlayDataset<OutputRow>>;