Mutations

Copymutation CreateConfiguration {
  ach {
    createConfiguration(
      input: {
        configId: "1dc71d60-f463-4bb6-b82a-ab42e2f923ff"
        endpointId: "b84512f1-a67e-4dc2-94dd-66c48b4d13fb"
        settlementAccountId: "37f7e8a6-171f-411d-ad59-7b1f40f505ea"
        exceptionAccountId: "3171b0c2-6e9f-41aa-a5a6-ee927deb27cf"
        suspenseAccountId: "3171b0c2-6e9f-41aa-a5a6-ee927deb27cf"
        journalId: "00000000-0000-0000-0000-000000000000"
      }
    ) {
      configurationId
    }
  }
}

Copymutation ProcessFile {
  ach {
    processFile(
      input: {
        fileKey: "ppd-credit.ach"
        configId: "1dc71d60-f463-4bb6-b82a-ab42e2f923ff"
      }
    ) {
      fileId
    }
  }
}

Copymutation AddToAccountSet(
  $accountSetCustomersId: UUID!
  $accountCustomerAliciaId: UUID!
) {
  addToAccountSet(
    id: $accountSetCustomersId
    member: { memberId: $accountCustomerAliciaId, memberType: ACCOUNT }
  ) {
    accountSetId
    members(first: 10) {
      nodes {
        ... on Account {
          accountId
          name
          code
        }
      }
    }
  }
}

Copymutation AdminCreateGroup {
  admin {
    createGroup(
      input: {
        id: "917e123a-b89d-4ab5-b11c-cdf6aac80b63"
        name: "empty-policy-1"
        description: "A group with an empty policy"
        policy: "[]"
      }
    ) {
      name
      description
      policy
    }
  }
}

Copymutation AdminCreateTenant {
  admin {
    createTenant(
      input: {
        id: "72a0097f-239e-48ec-a417-49c318332ed6"
        accountId: "sandbox"
        name: "Sandbox"
        description: "Sandbox tenant for testing"
      }
    ) {
      accountId
      name
    }
  }
}

Copymutation AdminCreateUser {
  admin {
    createUser(
      input: {
        id: "9cc8bd28-a36d-502e-89fd-7f1410c1b90a"
        groupIds: ["d57bd759-73d5-4452-a73e-12b590324e35"]
        email: "george@twisp.com"
      }
    ) {
      id
      email
      groupIds
    }
  }
}

Copymutation AdminDeleteGroup {
  admin {
    deleteGroup(name: "empty-policy-1") {
      name
    }
  }
}

Copymutation AdminDeleteTenant {
  admin {
    deleteTenant(accountId: "sandbox") {
      accountId
    }
  }
}

Copymutation AdminDeleteUser {
  admin {
    deleteUser(email: "george@twisp.com") {
      email
    }
  }
}

Copymutation AdminUpdateGroup {
  admin {
    updateGroup(
      input: {
        name: "empty-policy-1"
        description: "An empty policy layer will default to the base policy."
        policy: "[{\"actions\": [\"*\"],\"effect\": \"DENY\",\"resources\":[\"*\"], \"assertions\": {\"always false\": \"1 == 0\"}}]"
      }
    ) {
      name
      description
      policy
    }
  }
}

Copymutation AdminUpdateTenant {
  admin {
    updateTenant(
      input: {
        accountId: "sandbox"
        description: "This is the sandbox tenant."
      }
    ) {
      accountId
      description
      version
    }
  }
}

Copymutation AdminUpdateUser {
  admin {
    updateUser(
      input: {
        email: "george@twisp.com"
        groupIds: ["152f0c89-6cba-53c9-955e-16d7cbc1f35e"]
      }
    ) {
      email
      groupIds
    }
  }
}

Copymutation CreateAuthClient($authClientGithub: String!) {
  auth {
    createClient(
      input: {
        principal: $authClientGithub
        name: "Github"
        policies: [
          {
            effect: ALLOW
            actions: [SELECT, INSERT, UPDATE, DELETE]
            resources: ["financial.*"]
            assertions: { isTrue: "true" }
          }
        ]
      }
    ) {
      principal
    }
  }
}

Copymutation DeleteAuthClient($authClientGithub: String!) {
  auth {
    deleteClient(principal: $authClientGithub) {
      principal
    }
  }
}

Copymutation UpdateAuthClient($authClientGithub: String!) {
  auth {
    updateClient(
      principal: $authClientGithub
      input: {
        policies: [
          {
            effect: ALLOW
            actions: [SELECT, INSERT]
            resources: ["financial.*"]
            assertions: { isTrue: "true" }
          }
        ]
      }
    ) {
      policies {
        effect
        actions
        resources
        assertions
      }
    }
  }
}

Copymutation InitializeCardTransactionCodes($journalGLId: UUID!) {
  cards {
    initializeCardTransactionCodes(input: { journalId: $journalGLId }) {
      accountId
      name
      code
    }
  }
}

Copymutation CreateAccount($accountCardSettlementId: UUID!) {
  createAccount(
    input: {
      accountId: $accountCardSettlementId
      name: "Card Settlement"
      code: "SETTLE.CARD"
      description: "Settlement account for card transactions."
      normalBalanceType: CREDIT
      status: ACTIVE
    }
  ) {
    accountId
    name
    code
    description
    normalBalanceType
  }
}

Copymutation CreateAccountSet($accountSetCustomersId: UUID!, $journalGLId: UUID!) {
  createAccountSet(
    input: {
      accountSetId: $accountSetCustomersId
      journalId: $journalGLId
      name: "Customers"
      description: "All customer wallets."
      normalBalanceType: DEBIT
    }
  ) {
    accountSetId
    name
    description
  }
}

Copymutation CreateCalculation {
  createCalculation(
    input: {
      calculationId: "5867b5dd-fc69-416c-80f5-62e8a53610d5"
      code: "EFFECTIVE_DATE"
      description: "Track balances per EFFECTIVE_DATE in an account."
      dimensions: [
        { alias: "effectiveDate", value: "context.vars.transaction.effective" }
      ]
    }
  ) {
    calculationId
    code
    description
    dimensions {
      alias
      value
    }
  }
}

Copymutation CreateJournal($journalGLId: UUID!) {
  createJournal(
    input: {
      journalId: $journalGLId
      name: "GL"
      description: "General Ledger"
      status: ACTIVE
    }
  ) {
    journalId
    name
    description
    status
  }
}

Copymutation CreateTranCode(
  $tcBookTransferId: UUID!
  $journalGLIdExp: Expression!
) {
  createTranCode(
    input: {
      tranCodeId: $tcBookTransferId
      code: "BOOK_TRANSFER"
      description: "Book transfer between two internal accounts."
      metadata: { category: "Internal" }
      params: [
        { name: "crAccount", type: UUID, description: "Account to credit." }
        { name: "drAccount", type: UUID, description: "Account to debit." }
        {
          name: "amount"
          type: DECIMAL
          description: "Amount with decimal, e.g. `1.23`."
        }
        {
          name: "currency"
          type: STRING
          description: "Currency used for transaction."
        }
        {
          name: "effective"
          type: DATE
          description: "Effective date for transaction."
        }
      ]
      transaction: {
        journalId: $journalGLIdExp
        effective: "params.effective"
        description: "'Book transfer for $' + string(params.amount)"
      }
      entries: [
        {
          accountId: "params.drAccount"
          units: "params.amount"
          currency: "params.currency"
          entryType: "'BOOK_TRANSFER_DR'"
          direction: "DEBIT"
          layer: "SETTLED"
        }
        {
          accountId: "params.crAccount"
          units: "params.amount"
          currency: "params.currency"
          entryType: "'BOOK_TRANSFER_CR'"
          direction: "CREDIT"
          layer: "SETTLED"
        }
      ]
    }
  ) {
    tranCodeId
  }
}

Copymutation DeleteAccount($accountCustomerBobbyId: UUID!) {
  deleteAccount(id: $accountCustomerBobbyId) {
    accountId
    status
  }
}

Copymutation DeleteAccountSet($accountSetCustomersId: UUID!) {
  deleteAccountSet(id: $accountSetCustomersId) {
    accountSetId
  }
}

Copymutation DeleteCalculation {
  deleteCalculation(id: "5867b5dd-fc69-416c-80f5-62e8a53610d5") {
    calculationId
  }
}

Copymutation DeleteJournal($journalGLId: UUID!) {
  deleteJournal(id: $journalGLId) {
    journalId
    status
  }
}

Copymutation DeleteTranCode($tcBookTransferId: UUID!) {
  deleteTranCode(id: $tcBookTransferId) {
    tranCodeId
    status
  }
}

Copymutation Cel(
  $id: String! = "uuid.New()" @cel
  $uppercase: String! = "strings.ToUpper(context.vars.lowercase)" @cel
  $expression: String! @cel
  $this: String! = "this.uppercase" @cel
  $nonCEL: String!
  $celNonCEL: String! = "this.nonCEL" @cel
) {
  evaluate(
    expressions: {
      a: "int(1)"
      b: "document.greeting + ' World!'"
      c: "decimal.Sub(decimal('1.234567'), decimal('0.987654321'))"
      d: "math.Max(double(123), double(456))"
      e: "size(string(document.uuid))"
      f: "document.upper"
      g: "document.expr"
      h: "document.this"
      i: "strings.ToUpper(document.celNonCEL)"
      j: "context.auth"
      k: "decimal('-inf')"
      l: "string(decimal('-inf'))"
    }
    document: {
      greeting: "Hello"
      uuid: $id
      upper: $uppercase
      expr: $expression
      this: $this
      nonCEL: $nonCEL
      celNonCEL: $celNonCEL
    }
  )
}

Copymutation CreateEndpoint {
  events {
    createEndpoint(
      input: {
        endpointId: "345940ed-2726-4b20-88aa-820857ac0e68"
        status: ENABLED
        endpointType: WEBHOOK
        url: "https://webhook.site/twisp-webhook-test"
        description: "subscribe to balance and account events"
        subscription: ["balance*", "account.*"]
      }
    ) {
      endpointId
      status
      endpointType
      url
      subscription
      description
    }
  }
}

Copymutation PostTransaction(
  $accountCustomerAliciaId: UUID!
  $accountCustomerBobbyId: UUID!
) {
  postTransaction(
    input: {
      transactionId: "6b5e47b6-60d2-49bf-8210-0e4c3dd3ec68"
      tranCode: "BOOK_TRANSFER"
      params: {
        crAccount: $accountCustomerAliciaId
        drAccount: $accountCustomerBobbyId
        amount: "1.00"
        currency: "USD"
        effective: "2022-09-08"
      }
    }
  ) {
    transactionId
  }
}

Copymutation SchemaCreateIndex {
  schema {
    createIndex(
      input: {
        name: "Transaction.metadata.category"
        on: Transaction
        unique: false
        partition: [
          { alias: "correlation_id", value: "document.correlation_id" }
        ]
        sort: [
          {
            alias: "category"
            value: "string(document.metadata.category)"
            sort: ASC
          }
        ]
        constraints: { hasCategory: "has(document.metadata.category)" }
      }
    ) {
      range {
        alias
        value
        sort
      }
      partition {
        alias
        value
      }
      on
      constraints
      unique
    }
  }
}

Copymutation SchemaDeleteIndex {
  schema {
    deleteIndex(name: "Transaction.metadata.category", on: Transaction) {
      name
      on
    }
  }
}

Copymutation UpdateAccount($accountCardSettlementId: UUID!) {
  updateAccount(id: $accountCardSettlementId, input: { code: "CARD.SETTLE" }) {
    accountId
    code
    history(first: 2) {
      nodes {
        version
        code
      }
    }
  }
}

Copymutation UpdateAccountSet($accountSetCustomersId: UUID!) {
  updateAccountSet(
    id: $accountSetCustomersId
    input: { name: "Customer Wallets" }
  ) {
    accountSetId
    name
    history(first: 2) {
      nodes {
        version
        name
      }
    }
  }
}

Copymutation UpdateJournal($journalGLId: UUID!) {
  updateJournal(
    id: $journalGLId
    input: { description: "_The_ ledger. The only one." }
  ) {
    journalId
    description
    history(first: 2) {
      nodes {
        version
        description
      }
    }
  }
}

Copymutation UpdateTranCode($tcBookTransferId: UUID!) {
  updateTranCode(
    id: $tcBookTransferId
    input: {
      description: "Book transfer between two customer wallet accounts."
      entries: [
        {
          accountId: "params.drAccount"
          units: "params.amount"
          currency: "params.currency"
          entryType: "'BOOK_TRANSFER_DR'"
          direction: "DEBIT"
          layer: "SETTLED"
          metadata: "{'first': 1}"
        }
        {
          accountId: "params.crAccount"
          units: "params.amount"
          currency: "params.currency"
          entryType: "'BOOK_TRANSFER_CR'"
          direction: "CREDIT"
          layer: "SETTLED"
          metadata: "{'second':2}"
        }
      ]
    }
  ) {
    tranCodeId
    description
    entries {
      metadata
    }
    history(first: 2) {
      nodes {
        version
        description
      }
    }
  }
}

Copymutation UpdateTransaction {
  updateTransaction(
    id: "6b5e47b6-60d2-49bf-8210-0e4c3dd3ec68"
    input: { metadata: { reconciled: true } }
  ) {
    transactionId
    metadata
    history(first: 2) {
      nodes {
        version
        metadata
      }
    }
  }
}

Copymutation VoidTransaction($transactionId: UUID!) {
  voidTransaction(id: $transactionId) {
    transactionId
    voidOf
  }
}

Copymutation uuid_formatting {
  warehouse {
    executeStatementSync(
      input: {
        sql: "select accountid, from_varbyte(accountid, 'hex') as uuid from account_history limit 1"
      }
    ) {
      records {
        fields {
          value {
            str
          }
        }
      }
      columnMetadata {
        name
      }
    }
  }
}