error: Error serializing '() => provider': index.js(19,37)
    
    '() => provider': index.js(19,37): captured
      variable 'provider' which indirectly referenced
        function '<anonymous>': dns.ts(17,22): which could not be serialized because
          arrow function captured 'this'. Assign 'this' to another name outside function and capture that.
    
    Function code:
      (inputs) => __awaiter(this, void 0, void 0, function* () {
                  yield this.init();
                  const record = {
                      type: inputs.type,
                      name: inputs.name,
      ...
    error: an unhandled error occurred: Program exited with non-zero exit code: 1

// @ts-ignore
import * as cloudflare from 'cloudflare'
import * as pulumi from '@pulumi/pulumi'
import * as dynamic from '@pulumi/pulumi/dynamic'
import { RunError } from '@pulumi/pulumi/errors'

class DNSProvider implements dynamic.ResourceProvider {
  create = async (inputs: any) => {
    let client = new cloudflare({
      email: process.env.CLOUDFLARE_EMAIL as string,
      key: process.env.CLOUDFLARE_TOKEN as string
    })

    let domains = await getDomains(client)

    const record = {
      type: inputs.type,
      name: inputs.name,
      content: inputs.content,
      ttl: inputs.ttl,
      priority: inputs.priority,
      proxied: inputs.proxied
    }

    const zoneID = domains[inputs.domain]

    let res
    try {
      res = await client.dnsRecords.add(zoneID, record)
    } catch (e) {
      throw new RunError(`Unable to add DNS record: ${e}`)
    }

    return {
      id: `dns:${zoneID}:${res.result.id}`
    }
  }

  delete = async (id: pulumi.ID, props: any) => {
    const data = await parseID(id)

    let client = new cloudflare({
      email: process.env.CLOUDFLARE_EMAIL as string,
      key: process.env.CLOUDFLARE_TOKEN as string
    })

    try {
      await client.dnsRecords.del(data.zoneID, data.recordID)
    } catch (e) {
      throw new RunError(`Unable to delete DNS record: ${e}`)
    }
  }
}

export interface DNSRecordArgs {
  domain: pulumi.Input<string>
  type: pulumi.Input<string>
  name: pulumi.Input<string>
  content: pulumi.Input<string>
  ttl?: pulumi.Input<string>
  priority?: pulumi.Input<string>
  proxied?: pulumi.Input<string>
}

export class DNSRecord extends pulumi.dynamic.Resource {
  constructor(name: string, args: DNSRecordArgs, opts?: pulumi.CustomResourceOptions) {
    super(new DNSProvider(), name, args, opts)
  }
}

async function getDomains(client: cloudflare) {
  let domains: {
    [domain: string]: string
  } = {}

  let zones
  try {
    zones = await client.zones.browse()
  } catch (e) {
    throw new RunError(`Exception happened when retrieving zone information: ${e}`)
  }

  for (let zone of zones.result) {
    domains[zone.name] = zone.id
  }

  return domains
}

function parseID(id: string) {
  const parts = id.split(':')

  if (parts.length !== 3) {
    throw new RunError(`Invalid id: ${id}`)
  }

  return {
    zoneID: parts[1],
    recordID: parts[2]
  }
}

dynamic.ResourceProvider

ProviderResource

DNSRecordArgs