stacker.news/api/resolvers/sub.js

import { GraphQLError } from 'graphql'
import serialize, { serializeInvoicable } from './serial'
import { TERRITORY_COST_MONTHLY, TERRITORY_COST_ONCE, TERRITORY_COST_YEARLY } from '../../lib/constants'
import { datePivot } from '../../lib/time'
import { ssValidate, territorySchema } from '../../lib/validate'

export function paySubQueries (sub, models) {
  let billingAt = datePivot(sub.billedLastAt, { months: 1 })
  let billAt = datePivot(sub.billedLastAt, { months: 2 })
  if (sub.billingType === 'ONCE') {
    return []
  } else if (sub.billingType === 'YEARLY') {
    billingAt = datePivot(sub.billedLastAt, { years: 1 })
    billAt = datePivot(sub.billedLastAt, { years: 2 })
  }

  const cost = BigInt(sub.billingCost) * BigInt(1000)

  return [
    models.user.update({
      where: {
        id: sub.userId
      },
      data: {
        msats: {
          decrement: cost
        }
      }
    }),
    // update 'em
    models.sub.update({
      where: {
        name: sub.name
      },
      data: {
        billedLastAt: billingAt,
        status: 'ACTIVE'
      }
    }),
    // record 'em
    models.subAct.create({
      data: {
        userId: sub.userId,
        subName: sub.name,
        msats: cost,
        type: 'BILLING'
      }
    }),
    models.$executeRaw`
            DELETE FROM pgboss.job
              WHERE name = 'territoryBilling'
              AND data->>'subName' = ${sub.name}
              AND completedon IS NULL`,
    // schedule 'em
    models.$queryRaw`
          INSERT INTO pgboss.job (name, data, startafter) VALUES ('territoryBilling',
            ${JSON.stringify({
              subName: sub.name
            })}::JSONB, ${billAt})`
  ]
}

export default {
  Query: {
    sub: async (parent, { name }, { models, me }) => {
      if (!name) return null

      if (me && name === 'jobs') {
        models.user.update({
          where: {
            id: me.id
          },
          data: {
            lastCheckedJobs: new Date()
          }
        }).catch(console.log)
      }

      return await models.sub.findUnique({
        where: {
          name
        }
      })
    },
    subs: async (parent, args, { models }) => {
      return await models.sub.findMany({
        where: {
          status: {
            not: 'STOPPED'
          }
        },
        orderBy: {
          name: 'asc'
        }
      })
    },
    subLatestPost: async (parent, { name }, { models, me }) => {
      const latest = await models.item.findFirst({
        where: {
          subName: name
        },
        orderBy: {
          createdAt: 'desc'
        }
      })

      return latest?.createdAt
    }
  },
  Mutation: {
    upsertSub: async (parent, { hash, hmac, ...data }, { me, models, lnd }) => {
      if (!me) {
        throw new GraphQLError('you must be logged in', { extensions: { code: 'UNAUTHENTICATED' } })
      }

      // XXX this is because we did the wrong thing and used the subName as a primary key
      const existing = await models.sub.findUnique({
        where: {
          name: data.name,
          userId: me.id
        }
      })

      await ssValidate(territorySchema, data, { models, me })

      if (existing) {
        return await updateSub(parent, data, { me, models, lnd, hash, hmac })
      } else {
        return await createSub(parent, data, { me, models, lnd, hash, hmac })
      }
    },
    paySub: async (parent, { name, hash, hmac }, { me, models, lnd }) => {
      // check that they own the sub
      const sub = await models.sub.findUnique({
        where: {
          name
        }
      })

      if (!sub) {
        throw new GraphQLError('sub not found', { extensions: { code: 'BAD_INPUT' } })
      }

      if (sub.userId !== me.id) {
        throw new GraphQLError('you do not own this sub', { extensions: { code: 'BAD_INPUT' } })
      }

      if (sub.status === 'ACTIVE') {
        return sub
      }

      const queries = paySubQueries(sub, models)
      if (queries.length === 0) {
        return sub
      }

      const results = await serializeInvoicable(
        queries,
        { models, lnd, hash, hmac, me, enforceFee: sub.billingCost })
      return results[1]
    }
  },
  Sub: {
    user: async (sub, args, { models }) => {
      if (sub.user) {
        return sub.user
      }
      return await models.user.findUnique({ where: { id: sub.userId } })
    }
  }
}

async function createSub (parent, data, { me, models, lnd, hash, hmac }) {
  const { billingType } = data
  let billingCost = TERRITORY_COST_MONTHLY
  let billAt = datePivot(new Date(), { months: 1 })

  if (billingType === 'ONCE') {
    billingCost = TERRITORY_COST_ONCE
    billAt = null
  } else if (billingType === 'YEARLY') {
    billingCost = TERRITORY_COST_YEARLY
    billAt = datePivot(new Date(), { years: 1 })
  }

  const cost = BigInt(1000) * BigInt(billingCost)

  try {
    const results = await serializeInvoicable([
      // bill 'em
      models.user.update({
        where: {
          id: me.id
        },
        data: {
          msats: {
            decrement: cost
          }
        }
      }),
      // create 'em
      models.sub.create({
        data: {
          ...data,
          billingCost,
          rankingType: 'WOT',
          userId: me.id
        }
      }),
      // record 'em
      models.subAct.create({
        data: {
          userId: me.id,
          subName: data.name,
          msats: cost,
          type: 'BILLING'
        }
      }),
      // schedule 'em
      ...(billAt
        ? [models.$queryRaw`
          INSERT INTO pgboss.job (name, data, startafter) VALUES ('territoryBilling',
            ${JSON.stringify({
              subName: data.name
            })}::JSONB, ${billAt})`]
        : [])
    ], { models, lnd, hash, hmac, me, enforceFee: billingCost })

    return results[1]
  } catch (error) {
    if (error.code === 'P2002') {
      throw new GraphQLError('name taken', { extensions: { code: 'BAD_INPUT' } })
    }
    throw error
  }
}

async function updateSub (parent, { name, ...data }, { me, models, lnd, hash, hmac }) {
  const { billingType } = data

  let billingCost = TERRITORY_COST_MONTHLY
  if (billingType === 'ONCE') {
    billingCost = TERRITORY_COST_ONCE
  } else if (billingType === 'YEARLY') {
    billingCost = TERRITORY_COST_YEARLY
  }

  try {
    const results = await serialize(models,
      // update 'em
      models.sub.update({
        data: {
          ...data,
          billingCost,
          billingType
        },
        where: {
          name
        }
      }))

    return results[0]
  } catch (error) {
    if (error.code === 'P2002') {
      throw new GraphQLError('name taken', { extensions: { code: 'BAD_INPUT' } })
    }
    throw error
  }
}