12 | //
13 | // # Generates a PDF with default data, then open the new PDF in preview
14 | // yarn node example/script/generate-html-to-pdf.js 5vqCxtgNsA2uzgMH0ps4cyQyadhA2Wdt && open example/script/generate.output.pdf
15 |
16 | const fs = require('fs')
17 | const path = require('path')
18 | const Anvil = require('../../src/index')
19 | const argv = require('yargs')
20 | .usage('Usage: $0 apiKey')
21 | .option('user-agent', {
22 | alias: 'a',
23 | type: 'string',
24 | description: 'Set the User-Agent on any requests made (default is "Anvil API Client")',
25 | })
26 | .option('stream', {
27 | alias: 's',
28 | type: 'boolean',
29 | description: 'Return the data as a stream (default is buffer)',
30 | })
31 | .demandCommand(1).argv
32 |
33 | const [apiKey] = argv._
34 | const returnAStream = argv.stream
35 | const userAgent = argv['user-agent']
36 |
37 | const baseURL = 'https://app.useanvil.com'
38 |
39 | const exampleData = {
40 | title: 'Example HTML to PDF',
41 | type: 'html',
42 | data: {
43 | html: `
44 |
45 |
46 | Lorem Ipsum is simply dummy text of the printing and typesetting
47 | industry. Lorem Ipsum has been the industry's standard dummy text
48 | ever since the 1500s, when an unknown printer took
49 | a galley of type and scrambled it to make a type specimen book.
50 |
51 |
52 |
53 | Contrary to popular belief, Lorem Ipsum is not simply random text.
54 | It has roots in a piece of classical Latin literature from
55 | 45 BC, making it over 2000 years old.
56 |
57 | `,
58 | css: `
59 | body { font-size: 14px; color: #171717; }
60 | .header-one { text-decoration: underline; }
61 | .header-two { font-style: underline; }
62 | `,
63 | },
64 | }
65 |
66 | async function main () {
67 | const clientOptions = {
68 | baseURL,
69 | apiKey,
70 | }
71 | if (userAgent) {
72 | clientOptions.userAgent = userAgent
73 | }
74 |
75 | const client = new Anvil(clientOptions)
76 |
77 | const generateOptions = {}
78 | if (returnAStream) {
79 | generateOptions.dataType = 'stream'
80 | }
81 |
82 | const { statusCode, data, errors } = await client.generatePDF(exampleData, generateOptions)
83 |
84 | if (statusCode === 200) {
85 | const scriptDir = __dirname
86 | const outputFilePath = path.join(scriptDir, 'generate.output.pdf')
87 |
88 | if (returnAStream) {
89 | const writeStream = fs.createWriteStream(outputFilePath, { encoding: null })
90 | await new Promise((resolve, reject) => {
91 | data.pipe(writeStream)
92 | data.on('error', reject)
93 | writeStream.on('finish', resolve)
94 | })
95 | } else {
96 | fs.writeFileSync(outputFilePath, data, { encoding: null })
97 | }
98 | } else {
99 | console.log(statusCode, JSON.stringify(errors || data, null, 2))
100 | }
101 | }
102 |
103 | main()
104 | .then(() => {
105 | process.exit(0)
106 | })
107 | .catch((err) => {
108 | console.log(err.stack || err.message)
109 | process.exit(1)
110 | })
111 |
--------------------------------------------------------------------------------
/example/script/generate-markdown-pdf.js:
--------------------------------------------------------------------------------
1 | // Calls the generatePDF Anvil endpoint with data specified to generate a PDF
2 | // with the Anvil API. Outputs the generated PDF in `example/script/generate.output.pdf`
3 | //
4 | // Usage examples:
5 | //
6 | // # Generates a PDF
7 | // yarn node example/script/generate-markdown-pdf.js []
8 | //
9 | // # Generates a PDF with default data, then open the new PDF in preview
10 | // yarn node example/script/generate-markdown-pdf.js 5vqCxtgNsA2uzgMH0ps4cyQyadhA2Wdt && open example/script/generate.output.pdf
11 | //
12 | // # Generate a PDF with your payload, then open the new PDF in preview
13 | // yarn node example/script/generate-markdown-pdf.js apiKeydef345 ./payload.json && open example/script/generate.output.pdf
14 | //
15 | // `payload.json` is an optional JSON file with the JSON data used to generate the PDF. e.g.
16 | //
17 | // {
18 | // "title": "My PDF Title",
19 | // "data": [{
20 | // "label": "Hello World!",
21 | // "content": "Lorem **ipsum** dolor sit _amet_."
22 | // }]
23 | // }
24 |
25 | const fs = require('fs')
26 | const path = require('path')
27 | const Anvil = require('../../src/index')
28 | const argv = require('yargs')
29 | .usage('Usage: $0 apiKey')
30 | .option('user-agent', {
31 | alias: 'a',
32 | type: 'string',
33 | description: 'Set the User-Agent on any requests made (default is "Anvil API Client")',
34 | })
35 | .option('stream', {
36 | alias: 's',
37 | type: 'boolean',
38 | description: 'Return the data as a stream (default is buffer)',
39 | })
40 | .demandCommand(1).argv
41 |
42 | const [apiKey, jsonPath] = argv._
43 | const returnAStream = argv.stream
44 | const userAgent = argv['user-agent']
45 |
46 | const baseURL = 'https://app.useanvil.com'
47 |
48 | const exampleData = jsonPath
49 | ? JSON.parse(fs.readFileSync(jsonPath, { encoding: 'utf8' }))
50 | : {
51 | title: 'Example Invoice',
52 | data: [{
53 | label: 'Name',
54 | content: 'Sally Jones',
55 | }, {
56 | content: 'Lorem **ipsum** dolor sit _amet_, consectetur adipiscing elit, sed [do eiusmod](https://www.useanvil.com/docs) tempor incididunt ut labore et dolore magna aliqua. Ut placerat orci nulla pellentesque dignissim enim sit amet venenatis.\n\nMi eget mauris pharetra et ultrices neque ornare aenean.\n\n* Sagittis eu volutpat odio facilisis.\n\n* Erat nam at lectus urna.',
57 | }, {
58 | table: {
59 | firstRowHeaders: true,
60 | rows: [
61 | ['Description', 'Quantity', 'Price'],
62 | ['4x Large Widgets', '4', '$40.00'],
63 | ['10x Medium Sized Widgets in dark blue', '10', '$100.00'],
64 | ['10x Small Widgets in white', '6', '$60.00'],
65 | ],
66 | },
67 | }],
68 | }
69 |
70 | async function main () {
71 | const clientOptions = {
72 | baseURL,
73 | apiKey,
74 | }
75 | if (userAgent) {
76 | clientOptions.userAgent = userAgent
77 | }
78 |
79 | const client = new Anvil(clientOptions)
80 |
81 | const generateOptions = {}
82 | if (returnAStream) {
83 | generateOptions.dataType = 'stream'
84 | }
85 |
86 | const { statusCode, data, errors } = await client.generatePDF(exampleData, generateOptions)
87 |
88 | if (statusCode === 200) {
89 | const scriptDir = __dirname
90 | const outputFilePath = path.join(scriptDir, 'generate.output.pdf')
91 |
92 | if (returnAStream) {
93 | const writeStream = fs.createWriteStream(outputFilePath, { encoding: null })
94 | await new Promise((resolve, reject) => {
95 | data.pipe(writeStream)
96 | data.on('error', reject)
97 | writeStream.on('finish', resolve)
98 | })
99 | } else {
100 | fs.writeFileSync(outputFilePath, data, { encoding: null })
101 | }
102 | } else {
103 | console.log(statusCode, JSON.stringify(errors || data, null, 2))
104 | }
105 | }
106 |
107 | main()
108 | .then(() => {
109 | process.exit(0)
110 | })
111 | .catch((err) => {
112 | console.log(err.stack || err.message)
113 | process.exit(1)
114 | })
115 |
--------------------------------------------------------------------------------
/example/script/get-etch-packet.js:
--------------------------------------------------------------------------------
1 | const Anvil = require('../../src/index')
2 | const argv = require('yargs')
3 | .usage('Usage: $0 apiKey etchPacketEid')
4 | .demandCommand(2).argv
5 |
6 | const [apiKey, etchPacketEid] = argv._
7 |
8 | async function main () {
9 | const clientOptions = {
10 | apiKey,
11 | }
12 |
13 | const client = new Anvil(clientOptions)
14 |
15 | const variables = {
16 | eid: etchPacketEid,
17 | }
18 |
19 | const { statusCode, data, errors } = await client.getEtchPacket({ variables })
20 | console.log(
21 | JSON.stringify({
22 | statusCode,
23 | data,
24 | errors,
25 | }, null, 2),
26 | )
27 | }
28 |
29 | main()
30 | .then(() => {
31 | process.exit(0)
32 | })
33 | .catch((err) => {
34 | console.log(err.stack || err.message)
35 | process.exit(1)
36 | })
37 |
--------------------------------------------------------------------------------
/example/static/test-pdf-nda.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/anvilco/node-anvil/ff56ea27765f50ddc0d4fdfb22e2d9fa40bf51bb/example/static/test-pdf-nda.pdf
--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
1 | const Dist = require('./dist')
2 |
3 | // This file is mainly just for cleaning up the exports to be intuitive/commonjs
4 | module.exports = Dist.default
5 | // This is here just for backwards compatibilty. Should be removed at next
6 | // major verison to avoid a breaking change
7 | module.exports.default = Dist.default
8 |
--------------------------------------------------------------------------------
/issue_template.md:
--------------------------------------------------------------------------------
1 | ## Expected Behavior
2 |
3 |
4 | ## Actual Behavior
5 |
6 |
7 | ## Steps to Reproduce the Problem
8 |
9 | 1.
10 | 1.
11 | 1.
12 |
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "@anvilco/anvil",
3 | "version": "3.3.2",
4 | "description": "Anvil API Client",
5 | "author": "Anvil Foundry Inc.",
6 | "homepage": "https://github.com/anvilco/node-anvil#readme",
7 | "license": "MIT",
8 | "keywords": [
9 | "pdf",
10 | "pdf-fill",
11 | "json-to-pdf"
12 | ],
13 | "bugs": {
14 | "url": "https://github.com/anvilco/node-anvil/issues"
15 | },
16 | "repository": {
17 | "type": "git",
18 | "url": "git+https://github.com/anvilco/node-anvil.git"
19 | },
20 | "engines": {
21 | "node": ">=14"
22 | },
23 | "publishConfig": {
24 | "registry": "https://registry.npmjs.org",
25 | "@anvilco:registry": "https://registry.npmjs.org"
26 | },
27 | "main": "index.js",
28 | "files": [
29 | "package.json",
30 | "README.md",
31 | "LICENSE.md",
32 | "CHANGELOG.md",
33 | "dist/",
34 | "types/",
35 | "example/",
36 | "!**/.DS_STORE",
37 | "!**/.DS_Store"
38 | ],
39 | "types": "./types/src/index.d.ts",
40 | "scripts": {
41 | "build": "babel src --out-dir ./dist",
42 | "clean": "yarn rimraf ./dist",
43 | "prepare": "yarn tsc && yarn clean && yarn build",
44 | "publish:beta": "npm publish --tag beta",
45 | "test": "yarn prepare && mocha --config ./test/mocha.js",
46 | "lint": "eslint 'src/**/*.js' 'test/**/*.js'",
47 | "lint:quiet": "yarn run lint --quiet",
48 | "test:debug": "yarn test --inspect-brk=0.0.0.0:9223",
49 | "test:watch": "nodemon --signal SIGINT --watch test --watch src -x 'yarn test'",
50 | "test-e2e:build": "rimraf test/e2e/node-anvil.tgz && node dev/build-e2e.mjs",
51 | "test-e2e:install": "npm --prefix test/e2e run prep && npm --prefix test/e2e install"
52 | },
53 | "dependencies": {
54 | "@anvilco/node-fetch": "^3.3.3-beta.0",
55 | "abort-controller": "^3.0.0",
56 | "extract-files": "^13",
57 | "limiter": "^2.1.0"
58 | },
59 | "devDependencies": {
60 | "@babel/cli": "^7.22.10",
61 | "@babel/core": "^7.18.2",
62 | "@babel/eslint-parser": "^7.18.2",
63 | "@babel/preset-env": "^7.22.10",
64 | "@babel/register": "^7.22.5",
65 | "@types/node": "^20.1.1",
66 | "bdd-lazy-var": "^2.5.4",
67 | "chai": "^4.3.6",
68 | "chai-as-promised": "^7.1.1",
69 | "eslint": "^8.11.0",
70 | "eslint-config-nicenice": "^3.0.0",
71 | "eslint-config-standard": "^17.0.0",
72 | "eslint-config-standard-jsx": "^11.0.0",
73 | "eslint-plugin-import": "^2.25.4",
74 | "eslint-plugin-n": "^16.0.1",
75 | "eslint-plugin-no-only-tests": "^2.4.0",
76 | "eslint-plugin-promise": "^6.0.0",
77 | "eslint-plugin-react": "^7.29.4",
78 | "eslint-plugin-react-camel-case": "^1.1.1",
79 | "eslint-plugin-standard": "^5.0.0",
80 | "mocha": "^10.0.0",
81 | "nodemon": "^3.0.1",
82 | "rimraf": "^5.0.0",
83 | "sinon": "^17.0.1",
84 | "sinon-chai": "^3.5.0",
85 | "typescript": "^5.0.4",
86 | "yargs": "^17.4.0"
87 | }
88 | }
89 |
--------------------------------------------------------------------------------
/pull_request_template.md:
--------------------------------------------------------------------------------
1 | ## Description of the change
2 |
3 | Description here
4 |
5 | ## Type of change
6 |
7 | - [ ] Bug fix (non-breaking change that fixes an issue)
8 | - [ ] New feature (non-breaking change that adds functionality)
9 | - [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
10 |
11 | ## Related issues
12 |
13 | Fixes
14 |
15 | ## Checklists
16 |
17 | ### Development
18 |
19 | - [ ] The code changed/added as part of this pull request has been covered with tests
20 | - [ ] All tests related to the changed code pass in development
21 | - [ ] No previous tests unrelated to the changed code fail in development
22 |
23 | ### Code review
24 |
25 | - [ ] This pull request has a descriptive title and information useful to a reviewer. There may be a screenshot or screencast attached.
26 | - [ ] At least one reviewer has been requested
27 | - [ ] Changes have been reviewed by at least one other engineer
28 | - [ ] The relevant project board has been selected in Projects to auto-link to this pull request
29 |
--------------------------------------------------------------------------------
/src/UploadWithOptions.js:
--------------------------------------------------------------------------------
1 | export default class UploadWithOptions {
2 | constructor (streamLikeThing, formDataAppendOptions) {
3 | this.streamLikeThing = streamLikeThing
4 | this.formDataAppendOptions = formDataAppendOptions
5 | }
6 |
7 | get options () {
8 | return this.formDataAppendOptions
9 | }
10 |
11 | get file () {
12 | return this.streamLikeThing
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/src/errors.js:
--------------------------------------------------------------------------------
1 | // See if the JSON looks like it's got errors
2 | export function looksLikeJsonError ({ json }) {
3 | return !!(json && (json.errors || json.message || json.name))
4 | }
5 |
6 | // Should return an array
7 | export function normalizeJsonErrors ({ json, statusText = 'Unknown Error' }) {
8 | if (json) {
9 | // Normal, GraphQL way
10 | if (json.errors) {
11 | return json.errors
12 | }
13 |
14 | // Alternative way from some REST calls:
15 | // {
16 | // "name": "AssertionError",
17 | // "message": "PDF did not generate properly from given HTML!"
18 | // }
19 | //
20 | // OR
21 | //
22 | // {
23 | // "name": "ValidationError",
24 | // "fields":[{ "message": "Required", "property": "data" }]
25 | // }
26 | if (json.message || json.name) {
27 | return [json]
28 | }
29 | }
30 |
31 | // Hmm, ok. Default way
32 | return [{ name: statusText, message: statusText }]
33 | }
34 |
35 | // Should return an array
36 | export function normalizeNodeError ({ error, statusText = 'Unknown Error' }) {
37 | if (error) {
38 | return [pickError(error)]
39 | }
40 |
41 | // Hmm, ok. Default way
42 | return [{ name: statusText, message: statusText }]
43 | }
44 |
45 | function pickError (error) {
46 | return (({ name, message, code, cause, stack }) => ({ name, message, code, cause, stack }))(error)
47 | }
48 |
--------------------------------------------------------------------------------
/src/graphql/index.js:
--------------------------------------------------------------------------------
1 | export * as queries from './queries'
2 | export * as mutations from './mutations'
3 |
--------------------------------------------------------------------------------
/src/graphql/mutations/createEtchPacket.js:
--------------------------------------------------------------------------------
1 | const defaultResponseQuery = `{
2 | eid
3 | name
4 | status
5 | isTest
6 | allowUpdates
7 | numberRemainingSigners
8 | detailsURL
9 | webhookURL
10 | completedAt
11 | archivedAt
12 | createdAt
13 | updatedAt
14 | documentGroup {
15 | eid
16 | status
17 | files
18 | signers {
19 | eid
20 | aliasId
21 | routingOrder
22 | name
23 | email
24 | status
25 | signActionType
26 | }
27 | }
28 | }`
29 |
30 | export const generateMutation = (responseQuery = defaultResponseQuery) => `
31 | mutation CreateEtchPacket(
32 | $name: String,
33 | $organizationEid: String,
34 | $files: [EtchFile!],
35 | $isDraft: Boolean,
36 | $isTest: Boolean,
37 | $signatureEmailSubject: String,
38 | $signatureEmailBody: String,
39 | $signatureProvider: String,
40 | $signaturePageOptions: JSON,
41 | $signers: [JSON!],
42 | $data: JSON,
43 | $webhookURL: String,
44 | $replyToName: String,
45 | $replyToEmail: String,
46 | $enableEmails: JSON,
47 | $createCastTemplatesFromUploads: Boolean,
48 | $duplicateCasts: Boolean,
49 | $mergePDFs: Boolean,
50 | $allowUpdates: Boolean
51 | ) {
52 | createEtchPacket(
53 | name: $name,
54 | organizationEid: $organizationEid,
55 | files: $files,
56 | isDraft: $isDraft,
57 | isTest: $isTest,
58 | signatureEmailSubject: $signatureEmailSubject,
59 | signatureEmailBody: $signatureEmailBody,
60 | signatureProvider: $signatureProvider,
61 | signaturePageOptions: $signaturePageOptions,
62 | signers: $signers,
63 | data: $data,
64 | webhookURL: $webhookURL,
65 | replyToName: $replyToName,
66 | replyToEmail: $replyToEmail,
67 | enableEmails: $enableEmails,
68 | createCastTemplatesFromUploads: $createCastTemplatesFromUploads,
69 | duplicateCasts: $duplicateCasts,
70 | mergePDFs: $mergePDFs,
71 | allowUpdates: $allowUpdates
72 | ) ${responseQuery}
73 | }`
74 |
--------------------------------------------------------------------------------
/src/graphql/mutations/forgeSubmit.js:
--------------------------------------------------------------------------------
1 | const defaultResponseQuery = `{
2 | id
3 | eid
4 | status
5 | continueURL
6 | payloadValue
7 | currentStep
8 | completedAt
9 | createdAt
10 | updatedAt
11 | signer {
12 | name
13 | email
14 | status
15 | routingOrder
16 | }
17 | weldData {
18 | id
19 | eid
20 | isTest
21 | isComplete
22 | agents
23 | }
24 | }`
25 |
26 | export const generateMutation = (responseQuery = defaultResponseQuery) => `
27 | mutation ForgeSubmit(
28 | $forgeEid: String!,
29 | $weldDataEid: String,
30 | $submissionEid: String,
31 | $payload: JSON!,
32 | $enforcePayloadValidOnCreate: Boolean,
33 | $currentStep: Int,
34 | $complete: Boolean,
35 | $isTest: Boolean,
36 | $timezone: String,
37 | $webhookURL: String,
38 | $groupArrayId: String,
39 | $groupArrayIndex: Int
40 | ) {
41 | forgeSubmit(
42 | forgeEid: $forgeEid,
43 | weldDataEid: $weldDataEid,
44 | submissionEid: $submissionEid,
45 | payload: $payload,
46 | enforcePayloadValidOnCreate: $enforcePayloadValidOnCreate,
47 | currentStep: $currentStep,
48 | complete: $complete,
49 | isTest: $isTest,
50 | timezone: $timezone,
51 | webhookURL: $webhookURL,
52 | groupArrayId: $groupArrayId,
53 | groupArrayIndex: $groupArrayIndex
54 | ) ${responseQuery}
55 | }`
56 |
--------------------------------------------------------------------------------
/src/graphql/mutations/generateEtchSignUrl.js:
--------------------------------------------------------------------------------
1 | export const generateMutation = () => `
2 | mutation GenerateEtchSignURL (
3 | $signerEid: String!,
4 | $clientUserId: String!,
5 | ) {
6 | generateEtchSignURL (
7 | signerEid: $signerEid,
8 | clientUserId: $clientUserId
9 | )
10 | }
11 | `
12 |
--------------------------------------------------------------------------------
/src/graphql/mutations/index.js:
--------------------------------------------------------------------------------
1 | export * as createEtchPacket from './createEtchPacket'
2 | export * as forgeSubmit from './forgeSubmit'
3 | export * as generateEtchSignUrl from './generateEtchSignUrl'
4 | export * as removeWeldData from './removeWeldData'
5 |
--------------------------------------------------------------------------------
/src/graphql/mutations/removeWeldData.js:
--------------------------------------------------------------------------------
1 | export const generateMutation = () => `
2 | mutation RemoveWeldData (
3 | $eid: String!,
4 | ) {
5 | removeWeldData (
6 | eid: $eid,
7 | )
8 | }`
9 |
--------------------------------------------------------------------------------
/src/graphql/queries/etchPacket.js:
--------------------------------------------------------------------------------
1 | const defaultResponseQuery = `{
2 | id
3 | eid
4 | name
5 | status
6 | isTest
7 | numberRemainingSigners
8 | webhookURL
9 | detailsURL
10 | completedAt
11 | archivedAt
12 | createdAt
13 | updatedAt
14 | documentGroup {
15 | id
16 | eid
17 | status
18 | files
19 | signers {
20 | id
21 | eid
22 | aliasId
23 | routingOrder
24 | name
25 | email
26 | status
27 | signActionType
28 | }
29 | }
30 | }`
31 |
32 | export const generateQuery = (responseQuery = defaultResponseQuery) => `
33 | query EtchPacket (
34 | $eid: String!,
35 | ) {
36 | etchPacket (
37 | eid: $eid,
38 | ) ${responseQuery}
39 | }
40 | `
41 |
--------------------------------------------------------------------------------
/src/graphql/queries/index.js:
--------------------------------------------------------------------------------
1 | export * as etchPacket from './etchPacket'
2 |
--------------------------------------------------------------------------------
/src/index.js:
--------------------------------------------------------------------------------
1 | import fs from 'fs'
2 | // We are only importing this for the type..
3 | import { Stream } from 'stream' // eslint-disable-line no-unused-vars
4 |
5 | import AbortController from 'abort-controller'
6 | import { RateLimiter } from 'limiter'
7 |
8 | import UploadWithOptions from './UploadWithOptions'
9 | import { version, description } from '../package.json'
10 | import { looksLikeJsonError, normalizeNodeError, normalizeJsonErrors } from './errors'
11 | import { queries, mutations } from './graphql'
12 | import {
13 | isFile,
14 | graphQLUploadSchemaIsValid,
15 | } from './validation'
16 |
17 | class Warning extends Error {}
18 |
19 | let extractFiles
20 | let FormDataModule
21 | let Fetch
22 | let fetch
23 |
24 | /**
25 | * @typedef AnvilOptions
26 | * @type {Object}
27 | * @property {string} [apiKey]
28 | * @property {string} [accessToken]
29 | * @property {string} [baseURL]
30 | * @property {string} [userAgent]
31 | * @property {number} [requestLimit]
32 | * @property {number} [requestLimitMS]
33 | */
34 |
35 | /**
36 | * @typedef GraphQLResponse
37 | * @type {Object}
38 | * @property {number} statusCode
39 | * @property {GraphQLResponseData} [data]
40 | * @property {Array} [errors]
41 | */
42 |
43 | /** @typedef {{
44 | data: {[ key: string]: any }
45 | }} GraphQLResponseData */
46 |
47 | /**
48 | * @typedef RESTResponse
49 | * @type {Object}
50 | * @property {number} statusCode
51 | * @property {Buffer|Stream|Object} [data]
52 | * @property {Array} [errors]
53 | * @property {any} [response] node-fetch Response
54 | */
55 |
56 | /** @typedef {{
57 | name: string;
58 | message: string;
59 | stack: string;
60 | code: string;
61 | cause?: any;
62 | }} NodeError */
63 |
64 | /** @typedef {{
65 | message: string,
66 | status?: number,
67 | name?: string,
68 | fields?: Array
69 | [key: string]: any
70 | }} ResponseError */
71 |
72 | /** @typedef {{
73 | message: string,
74 | property?: string,
75 | [key: string]: any
76 | }} ResponseErrorField */
77 |
78 | /** @typedef {{
79 | path: string
80 | }} Readable */
81 |
82 | // Ignoring the below since they are dynamically created depepending on what's
83 | // inside the `src/graphql` directory.
84 | const {
85 | mutations: {
86 | // @ts-ignore
87 | createEtchPacket: {
88 | generateMutation: generateCreateEtchPacketMutation,
89 | },
90 | // @ts-ignore
91 | forgeSubmit: {
92 | generateMutation: generateForgeSubmitMutation,
93 | },
94 | // @ts-ignore
95 | generateEtchSignUrl: {
96 | generateMutation: generateEtchSignUrlMutation,
97 | },
98 | // @ts-ignore
99 | removeWeldData: {
100 | generateMutation: generateRemoveWeldDataMutation,
101 | },
102 | },
103 | queries: {
104 | // @ts-ignore
105 | etchPacket: {
106 | generateQuery: generateEtchPacketQuery,
107 | },
108 | },
109 | } = { queries, mutations }
110 |
111 | const DATA_TYPE_STREAM = 'stream'
112 | const DATA_TYPE_BUFFER = 'buffer'
113 | const DATA_TYPE_ARRAY_BUFFER = 'arrayBuffer'
114 | const DATA_TYPE_JSON = 'json'
115 |
116 | const SUPPORTED_BINARY_DATA_TYPES = Object.freeze([
117 | DATA_TYPE_STREAM,
118 | DATA_TYPE_BUFFER,
119 | DATA_TYPE_ARRAY_BUFFER,
120 | ])
121 |
122 | // Version number to use for latest versions (usually drafts)
123 | const VERSION_LATEST = -1
124 | // Version number to use for the latest published version.
125 | // This is the default when a version is not provided.
126 | const VERSION_LATEST_PUBLISHED = -2
127 |
128 | const defaultOptions = {
129 | baseURL: 'https://app.useanvil.com',
130 | userAgent: `${description}/${version}`,
131 | }
132 |
133 | const FILENAME_IGNORE_MESSAGE = 'If you think you can ignore this, please pass `options.ignoreFilenameValidation` as `true`.'
134 |
135 | const failBufferMS = 50
136 |
137 | class Anvil {
138 | // {
139 | // apiKey: ,
140 | // accessToken: , // OR oauth access token
141 | // baseURL: 'https://app.useanvil.com'
142 | // userAgent: 'Anvil API Client/2.0.0'
143 | // }
144 | /**
145 | * @param {AnvilOptions?} options
146 | */
147 | constructor (options) {
148 | if (!options) throw new Error('options are required')
149 |
150 | this.options = {
151 | ...defaultOptions,
152 | requestLimit: 1,
153 | requestLimitMS: 1000,
154 | ...options,
155 | }
156 |
157 | const { apiKey, accessToken } = this.options
158 | if (!(apiKey || accessToken)) throw new Error('apiKey or accessToken required')
159 |
160 | this.authHeader = accessToken
161 | ? `Bearer ${Buffer.from(accessToken, 'ascii').toString('base64')}`
162 | : `Basic ${Buffer.from(`${apiKey}:`, 'ascii').toString('base64')}`
163 |
164 | // Indicates that we have not dynamically set the Rate Limit from the API response
165 | this.hasSetLimiterFromResponse = false
166 | // Indicates that we are in the process setting the Rate Limit from an API response
167 | this.limiterSettingInProgress = false
168 | // A Promise that all early requests will have to wait for before continuing on. This
169 | // promise will be resolved by the first API response
170 | this.rateLimiterSetupPromise = new Promise((resolve) => {
171 | this.rateLimiterPromiseResolver = resolve
172 | })
173 |
174 | // Set our initial limiter
175 | this._setRateLimiter({ tokens: this.options.requestLimit, intervalMs: this.options.requestLimitMS })
176 | }
177 |
178 | /**
179 | * @param {Object} options
180 | * @param {number} options.tokens
181 | * @param {number} options.intervalMs
182 | * @private
183 | */
184 | _setRateLimiter ({ tokens, intervalMs }) {
185 | if (
186 | // Both must be truthy
187 | !(tokens && intervalMs) ||
188 | // Things should not be the same as they already are
189 | (this.limitTokens === tokens && this.limitIntervalMs === intervalMs)
190 | ) {
191 | return
192 | }
193 |
194 | const newLimiter = new RateLimiter({ tokensPerInterval: tokens, interval: intervalMs })
195 |
196 | // If we already had a limiter, let's try to pick up where it left off
197 | if (this.limiter) {
198 | const tokensInUse = Math.max(
199 | // getTokensRemaining() can return a decimal, so we round it down
200 | // so as to be conservative about potentially hitting the API again
201 | this.limitTokens - Math.floor(this.limiter.getTokensRemaining()),
202 | 0,
203 | )
204 | const tokensToRemove = Math.min(tokens, tokensInUse)
205 | if (tokensToRemove) {
206 | newLimiter.tryRemoveTokens(tokensToRemove)
207 | }
208 | delete this.limiter
209 | }
210 |
211 | this.limitTokens = tokens
212 | this.limitIntervalMs = intervalMs
213 | this.limiter = newLimiter
214 | }
215 |
216 | /**
217 | * Perform some handy/necessary things for a GraphQL file upload to make it work
218 | * with this client and with our backend
219 | *
220 | * @param {string|Buffer|Readable|File|Blob} pathOrStreamLikeThing - Either a string path to a file,
221 | * a Buffer, or a Stream-like thing that is compatible with form-data as an append.
222 | * @param {Object} [formDataAppendOptions] - User can specify options to be passed to the form-data.append
223 | * call. This should be done if a stream-like thing is not one of the common types that
224 | * form-data can figure out on its own.
225 | *
226 | * @return {UploadWithOptions} - A class that wraps the stream-like-thing and any options
227 | * up together nicely in a way that we can also tell that it was us who did it.
228 | */
229 | static prepareGraphQLFile (pathOrStreamLikeThing, { ignoreFilenameValidation, ...formDataAppendOptions } = {}) {
230 | if (typeof pathOrStreamLikeThing === 'string') {
231 | // @ts-ignore
232 | // no-op for this logic path. It's a path and we will load it later and it will at least
233 | // have the file's name as a filename to possibly use.
234 | } else if (
235 | !formDataAppendOptions ||
236 | (
237 | formDataAppendOptions && !(
238 | // Require the filename or the ignoreFilenameValidation option. This is an escape hatch
239 | // for things we didn't anticipate to cause problems
240 | formDataAppendOptions.filename || ignoreFilenameValidation
241 | )
242 | )
243 | ) {
244 | // OK, there's a chance here that a `filename` needs to be provided via formDataAppendOptions
245 | if (
246 | // Buffer has no way to get the filename
247 | pathOrStreamLikeThing instanceof Buffer ||
248 | !(
249 | // Some stream things have a string path in them (can also be a buffer, but we want/need string)
250 | // @ts-ignore
251 | (pathOrStreamLikeThing.path && typeof pathOrStreamLikeThing.path === 'string') ||
252 | // A File might look like this
253 | // @ts-ignore
254 | (pathOrStreamLikeThing.name && typeof pathOrStreamLikeThing.name === 'string')
255 | )
256 | ) {
257 | let message = 'For this type of input, `options.filename` must be provided to prepareGraphQLFile.' + ' ' + FILENAME_IGNORE_MESSAGE
258 | try {
259 | if (pathOrStreamLikeThing && pathOrStreamLikeThing.constructor && pathOrStreamLikeThing.constructor.name) {
260 | message = `When passing a ${pathOrStreamLikeThing.constructor.name} to prepareGraphQLFile, \`options.filename\` must be provided. ${FILENAME_IGNORE_MESSAGE}`
261 | }
262 | } catch (err) {
263 | console.error(err)
264 | }
265 |
266 | throw new Error(message)
267 | }
268 | }
269 |
270 | return new UploadWithOptions(pathOrStreamLikeThing, formDataAppendOptions)
271 | }
272 |
273 | /**
274 | * Runs the createEtchPacket mutation.
275 | * @param {Object} data
276 | * @param {Object} data.variables
277 | * @param {string} [data.responseQuery]
278 | * @param {string} [data.mutation]
279 | * @returns {Promise}
280 | */
281 | createEtchPacket ({ variables, responseQuery, mutation }) {
282 | return this.requestGraphQL(
283 | {
284 | query: mutation || generateCreateEtchPacketMutation(responseQuery),
285 | variables,
286 | },
287 | { dataType: DATA_TYPE_JSON },
288 | )
289 | }
290 |
291 | /**
292 | * @param {string} documentGroupEid
293 | * @param {Object} [clientOptions]
294 | * @returns {Promise}
295 | */
296 | downloadDocuments (documentGroupEid, clientOptions = {}) {
297 | const { dataType = DATA_TYPE_BUFFER } = clientOptions
298 | if (dataType && !SUPPORTED_BINARY_DATA_TYPES.includes(dataType)) {
299 | throw new Error(`dataType must be one of: ${SUPPORTED_BINARY_DATA_TYPES.join('|')}`)
300 | }
301 | return this.requestREST(
302 | `/api/document-group/${documentGroupEid}.zip`,
303 | { method: 'GET' },
304 | {
305 | ...clientOptions,
306 | dataType,
307 | },
308 | )
309 | }
310 |
311 | /**
312 | * @param {string} pdfTemplateID
313 | * @param {Object} payload
314 | * @param {Object} [clientOptions]
315 | * @returns {Promise}
316 | */
317 | fillPDF (pdfTemplateID, payload, clientOptions = {}) {
318 | const { dataType = DATA_TYPE_BUFFER } = clientOptions
319 | if (dataType && !SUPPORTED_BINARY_DATA_TYPES.includes(dataType)) {
320 | throw new Error(`dataType must be one of: ${SUPPORTED_BINARY_DATA_TYPES.join('|')}`)
321 | }
322 |
323 | const versionNumber = clientOptions.versionNumber
324 | const url = versionNumber
325 | ? `/api/v1/fill/${pdfTemplateID}.pdf?versionNumber=${versionNumber}`
326 | : `/api/v1/fill/${pdfTemplateID}.pdf`
327 |
328 | return this.requestREST(
329 | url,
330 | {
331 | method: 'POST',
332 | body: JSON.stringify(payload),
333 | headers: {
334 | 'Content-Type': 'application/json',
335 | },
336 | },
337 | {
338 | ...clientOptions,
339 | dataType,
340 | },
341 | )
342 | }
343 |
344 | /**
345 | * @param {Object} data
346 | * @param {Object} data.variables
347 | * @param {string} [data.responseQuery]
348 | * @param {string} [data.mutation]
349 | * @returns {Promise}
350 | */
351 | forgeSubmit ({ variables, responseQuery, mutation }) {
352 | return this.requestGraphQL(
353 | {
354 | query: mutation || generateForgeSubmitMutation(responseQuery),
355 | variables,
356 | },
357 | { dataType: DATA_TYPE_JSON },
358 | )
359 | }
360 |
361 | /**
362 | * @param {Object} payload
363 | * @param {Object} [clientOptions]
364 | * @returns {Promise}
365 | */
366 | generatePDF (payload, clientOptions = {}) {
367 | const { dataType = DATA_TYPE_BUFFER } = clientOptions
368 | if (dataType && !SUPPORTED_BINARY_DATA_TYPES.includes(dataType)) {
369 | throw new Error(`dataType must be one of: ${SUPPORTED_BINARY_DATA_TYPES.join('|')}`)
370 | }
371 |
372 | return this.requestREST(
373 | '/api/v1/generate-pdf',
374 | {
375 | method: 'POST',
376 | body: JSON.stringify(payload),
377 | headers: {
378 | 'Content-Type': 'application/json',
379 | },
380 | },
381 | {
382 | ...clientOptions,
383 | dataType,
384 | },
385 | )
386 | }
387 |
388 | /**
389 | * @param {Object} data
390 | * @param {Object} data.variables
391 | * @param {string} [data.responseQuery]
392 | * @returns {Promise}
393 | */
394 | getEtchPacket ({ variables, responseQuery }) {
395 | return this.requestGraphQL(
396 | {
397 | query: generateEtchPacketQuery(responseQuery),
398 | variables,
399 | },
400 | { dataType: DATA_TYPE_JSON },
401 | )
402 | }
403 |
404 | /**
405 | * @param {Object} data
406 | * @param {Object} data.variables
407 | * @returns {Promise<{url?: string, errors?: Array, statusCode: number}>}
408 | */
409 | async generateEtchSignUrl ({ variables }) {
410 | const { statusCode, data, errors } = await this.requestGraphQL(
411 | {
412 | query: generateEtchSignUrlMutation(),
413 | variables,
414 | },
415 | { dataType: DATA_TYPE_JSON },
416 | )
417 |
418 | return {
419 | statusCode,
420 | url: data && data.data && data.data.generateEtchSignURL,
421 | errors,
422 | }
423 | }
424 |
425 | /**
426 | * @param {Object} data
427 | * @param {Object} data.variables
428 | * @param {string} [data.mutation]
429 | * @returns {Promise}
430 | */
431 | removeWeldData ({ variables, mutation }) {
432 | return this.requestGraphQL(
433 | {
434 | query: mutation || generateRemoveWeldDataMutation(),
435 | variables,
436 | },
437 | { dataType: DATA_TYPE_JSON },
438 | )
439 | }
440 |
441 | /**
442 | * @param {Object} data
443 | * @param {string} data.query
444 | * @param {Object} [data.variables]
445 | * @param {Object} [clientOptions]
446 | * @returns {Promise}
447 | */
448 | async requestGraphQL ({ query, variables = {} }, clientOptions) {
449 | // Some helpful resources on how this came to be:
450 | // https://github.com/jaydenseric/graphql-upload/issues/125#issuecomment-440853538
451 | // https://zach.codes/building-a-file-upload-hook/
452 | // https://github.com/jaydenseric/graphql-react/blob/1b1234de5de46b7a0029903a1446dcc061f37d09/src/universal/graphqlFetchOptions.mjs
453 | // https://www.npmjs.com/package/extract-files
454 |
455 | const options = {
456 | method: 'POST',
457 | headers: {},
458 | }
459 |
460 | const originalOperation = { query, variables }
461 |
462 | extractFiles ??= (await import('extract-files/extractFiles.mjs')).default
463 |
464 | const {
465 | clone: augmentedOperation,
466 | files: filesMap,
467 | } = extractFiles(originalOperation, isFile)
468 |
469 | const operationJSON = JSON.stringify(augmentedOperation)
470 |
471 | // Checks for both File uploads and Base64 uploads
472 | if (!graphQLUploadSchemaIsValid(originalOperation)) {
473 | throw new Error('Invalid File schema detected')
474 | }
475 |
476 | if (filesMap.size) {
477 | // @ts-ignore
478 | const abortController = new AbortController()
479 | Fetch ??= await import('@anvilco/node-fetch')
480 | // This is a dependency of 'node-fetch'`
481 | FormDataModule ??= await import('formdata-polyfill/esm.min.js')
482 | const form = new FormDataModule.FormData()
483 |
484 | form.append('operations', operationJSON)
485 |
486 | const map = {}
487 | let i = 0
488 | filesMap.forEach(paths => {
489 | map[++i] = paths
490 | })
491 | form.append('map', JSON.stringify(map))
492 |
493 | i = 0
494 | filesMap.forEach((paths, file) => {
495 | // Ensure that the file has been run through the prepareGraphQLFile process
496 | // and checks
497 | if (file instanceof UploadWithOptions === false) {
498 | file = Anvil.prepareGraphQLFile(file)
499 | }
500 | let { filename, mimetype, ignoreFilenameValidation } = file.options || {}
501 | file = file.file
502 |
503 | if (!file) {
504 | throw new Error('No file provided. Options were: ' + JSON.stringify(options))
505 | }
506 |
507 | // If this is a stream-like thing, attach a listener to the 'error' event so that we
508 | // can cancel the API call if something goes wrong
509 | if (typeof file.on === 'function') {
510 | file.on('error', (err) => {
511 | console.warn(err)
512 | abortController.abort()
513 | })
514 | }
515 |
516 | // If file a path to a file?
517 | if (typeof file === 'string') {
518 | file = Fetch.fileFromSync(file, mimetype)
519 | } else if (file instanceof Buffer) {
520 | const buffer = file
521 | // https://developer.mozilla.org/en-US/docs/Web/API/File/File
522 | file = new Fetch.File(
523 | [buffer],
524 | filename,
525 | {
526 | type: mimetype,
527 | },
528 | )
529 | } else if (file instanceof Stream) {
530 | // https://github.com/node-fetch/node-fetch#post-data-using-a-file
531 | const stream = file
532 | file = {
533 | [Symbol.toStringTag]: 'File',
534 | // @ts-ignore
535 | size: fs.statSync(stream.path).size,
536 | stream: () => stream,
537 | type: mimetype,
538 | }
539 |
540 | // @ts-ignore
541 | filename ??= stream.path.split('/').pop()
542 | } else if (file.constructor.name !== 'File') {
543 | // Like a Blob or something
544 | if (!filename) {
545 | const name = file.name || file.path
546 | if (name) {
547 | filename = name.split('/').pop()
548 | }
549 |
550 | if (!filename && !ignoreFilenameValidation) {
551 | console.warn(new Warning('No filename provided. Please provide a filename to the file options.'))
552 | }
553 | }
554 | }
555 |
556 | // https://developer.mozilla.org/en-US/docs/Web/API/FormData/append
557 | form.append(`${++i}`, file, filename)
558 | })
559 |
560 | options.signal = abortController.signal
561 | options.body = form
562 | } else {
563 | options.headers['Content-Type'] = 'application/json'
564 | options.body = operationJSON
565 | }
566 |
567 | const {
568 | statusCode,
569 | data,
570 | errors,
571 | } = await this._wrapRequest(
572 | () => this._request('/graphql', options),
573 | clientOptions,
574 | )
575 |
576 | return {
577 | statusCode,
578 | data,
579 | errors,
580 | }
581 | }
582 |
583 | /**
584 | * @param {string} url
585 | * @param {Object} fetchOptions
586 | * @param {Object} [clientOptions]
587 | * @returns {Promise}
588 | */
589 | async requestREST (url, fetchOptions, clientOptions) {
590 | const {
591 | response,
592 | statusCode,
593 | data,
594 | errors,
595 | } = await this._wrapRequest(
596 | () => this._request(url, fetchOptions),
597 | clientOptions,
598 | )
599 |
600 | return {
601 | response,
602 | statusCode,
603 | data,
604 | errors,
605 | }
606 | }
607 |
608 | // ******************************************************************************
609 | // ___ _ __
610 | // / _ \____(_) _____ _/ /____
611 | // / ___/ __/ / |/ / _ `/ __/ -_)
612 | // /_/ /_/ /_/|___/\_,_/\__/\__/
613 | //
614 | // ALL THE BELOW CODE IS CONSIDERED PRIVATE, AND THE API OR INTERNALS MAY CHANGE AT ANY TIME
615 | // USERS OF THIS MODULE SHOULD NOT USE ANY OF THESE METHODS DIRECTLY
616 | // ******************************************************************************
617 |
618 | async _request (...args) {
619 | // Only load Fetch once per module process lifetime
620 | Fetch = Fetch || await import('@anvilco/node-fetch')
621 | fetch = Fetch.default
622 | // Monkey-patch so we only try any of this once per Anvil Client instance
623 | this._request = this.__request
624 | return this._request(...args)
625 | }
626 |
627 | /**
628 | * @param {string} url
629 | * @param {Object} options
630 | * @returns {Promise}
631 | * @private
632 | */
633 | __request (url, options) {
634 | if (!url.startsWith(this.options.baseURL)) {
635 | url = this._url(url)
636 | }
637 | const opts = this._addDefaultHeaders(options)
638 | return fetch(url, opts)
639 | }
640 |
641 | /**
642 | * @param {CallableFunction} retryableRequestFn
643 | * @param {Object} [clientOptions]
644 | * @returns {Promise<*>}
645 | * @private
646 | */
647 | _wrapRequest (retryableRequestFn, clientOptions = {}) {
648 | return this._throttle(async (retry) => {
649 | let { dataType, debug } = clientOptions
650 | const response = await retryableRequestFn()
651 |
652 | if (!this.hasSetLimiterFromResponse) {
653 | // OK, this is the response sets the rate-limiter values from the
654 | // server response:
655 |
656 | // Set up the new Rate Limiter
657 | const tokens = parseInt(response.headers.get('x-ratelimit-limit'))
658 | const intervalMs = parseInt(response.headers.get('x-ratelimit-interval-ms'))
659 | this._setRateLimiter({ tokens, intervalMs })
660 |
661 | // Adjust the gates that make this only happen once.
662 | this.hasSetLimiterFromResponse = true
663 | this.limiterSettingInProgress = false
664 | // Resolve the Promise that everyone else was waiting for
665 | this.rateLimiterPromiseResolver()
666 | }
667 |
668 | const { status: statusCode, statusText } = response
669 |
670 | if (statusCode === 429) {
671 | return retry(getRetryMS(response.headers.get('retry-after')))
672 | }
673 |
674 | let json
675 | let isError = false
676 | let nodeError
677 |
678 | const contentType = response.headers.get('content-type') || response.headers.get('Content-Type') || ''
679 |
680 | // No matter what we were expecting, if the response is JSON, let's parse it and look for
681 | // signs of errors
682 | if (contentType.toLowerCase().includes('application/json')) {
683 | // Re-set the dataType so we don't fall into the wrong flow later on
684 | dataType = DATA_TYPE_JSON
685 | try {
686 | json = await response.json()
687 | isError = looksLikeJsonError({ json })
688 | } catch (err) {
689 | nodeError = err
690 | if (debug) {
691 | console.warn(`Problem parsing JSON response for status ${statusCode}:`)
692 | console.warn(err)
693 | }
694 | }
695 | }
696 |
697 | if (nodeError || isError || statusCode >= 300) {
698 | const errors = nodeError ? normalizeNodeError({ error: nodeError }) : normalizeJsonErrors({ json, statusText })
699 | return { response, statusCode, errors }
700 | }
701 |
702 | let data
703 |
704 | switch (dataType) {
705 | case DATA_TYPE_STREAM:
706 | data = response.body
707 | break
708 | case DATA_TYPE_BUFFER:
709 | // Will ask for it as an arrayBuffer (to avoid deprecation warning) but then convert it to a
710 | // Node Buffer.
711 | // https://github.com/node-fetch/node-fetch/pull/1212
712 | // https://github.com/node-fetch/node-fetch/pull/1345
713 | // https://github.com/anvilco/node-anvil/pull/442
714 | data = Buffer.from(await response.arrayBuffer())
715 | break
716 | case DATA_TYPE_ARRAY_BUFFER:
717 | data = await response.arrayBuffer()
718 | break
719 | case DATA_TYPE_JSON:
720 | // Can't call json() twice, so we'll see if we already did that
721 | data = json || await response.json()
722 | break
723 | default:
724 | console.warn('Using default response dataType of "json". Please specify a dataType.')
725 | data = await response.json()
726 | break
727 | }
728 |
729 | return {
730 | response,
731 | data,
732 | statusCode,
733 | }
734 | })
735 | }
736 |
737 | /**
738 | * @param {string} path
739 | * @returns {string}
740 | * @private
741 | */
742 | _url (path) {
743 | return this.options.baseURL + path
744 | }
745 |
746 | /**
747 | * @param {Object} headerObject
748 | * @param {Object} headerObject.options
749 | * @param {Object} headerObject.headers
750 | * @param {Object} [internalOptions]
751 | * @returns {*&{headers: {}}}
752 | * @private
753 | */
754 | _addHeaders ({ options: existingOptions, headers: newHeaders }, internalOptions = {}) {
755 | const { headers: existingHeaders = {} } = existingOptions
756 | const { defaults = false } = internalOptions
757 |
758 | newHeaders = defaults
759 | ? newHeaders
760 | : Object.entries(newHeaders).reduce((acc, [key, val]) => {
761 | if (val != null) {
762 | acc[key] = val
763 | }
764 |
765 | return acc
766 | }, {})
767 |
768 | return {
769 | ...existingOptions,
770 | headers: {
771 | ...existingHeaders,
772 | ...newHeaders,
773 | },
774 | }
775 | }
776 |
777 | /**
778 | * @param {Object} options
779 | * @returns {*}
780 | * @private
781 | */
782 | _addDefaultHeaders (options) {
783 | const { userAgent } = this.options
784 | return this._addHeaders(
785 | {
786 | options,
787 | headers: {
788 | 'User-Agent': userAgent,
789 | Authorization: this.authHeader,
790 | },
791 | },
792 | { defaults: true },
793 | )
794 | }
795 |
796 | /**
797 | * @param {CallableFunction} fn
798 | * @returns {Promise<*>}
799 | * @private
800 | */
801 | async _throttle (fn) {
802 | // If this is one of the first requests being made, we'll want to dynamically
803 | // set the Rate Limiter values from the API response, and hold up everyone else
804 | // while this is happening.
805 | // If we've already gone through the whole setup from the response, then nothing
806 | // special to do
807 | if (!this.hasSetLimiterFromResponse) {
808 | // If limiter setting is already in progress, then this request will have to wait
809 | if (this.limiterSettingInProgress) {
810 | await this.rateLimiterSetupPromise
811 | } else {
812 | // Set the gate so that subsequent calls will have to wait for the resolution
813 | this.limiterSettingInProgress = true
814 | }
815 | }
816 |
817 | const remainingRequests = await this.limiter.removeTokens(1)
818 | if (remainingRequests < 1) {
819 | await sleep(this.options.requestLimitMS + failBufferMS)
820 | }
821 | const retry = async (ms) => {
822 | await sleep(ms)
823 | return this._throttle(fn)
824 | }
825 |
826 | return fn(retry)
827 | }
828 | }
829 |
830 | Anvil.UploadWithOptions = UploadWithOptions
831 |
832 | /**
833 | * @param {string} retryAfterSeconds
834 | * @returns {number}
835 | * @private
836 | */
837 | function getRetryMS (retryAfterSeconds) {
838 | return Math.round((Math.abs(parseFloat(retryAfterSeconds)) || 0) * 1000) + failBufferMS
839 | }
840 |
841 | /**
842 | * @param {number} ms
843 | * @returns {Promise}
844 | * @private
845 | */
846 | function sleep (ms) {
847 | return new Promise((resolve) => {
848 | setTimeout(resolve, ms)
849 | })
850 | }
851 |
852 | Anvil.VERSION_LATEST = VERSION_LATEST
853 | Anvil.VERSION_LATEST_PUBLISHED = VERSION_LATEST_PUBLISHED
854 |
855 | export default Anvil
856 |
--------------------------------------------------------------------------------
/src/validation.js:
--------------------------------------------------------------------------------
1 | import fs from 'fs'
2 | import UploadWithOptions from './UploadWithOptions'
3 |
4 | // https://www.npmjs.com/package/extract-files/v/6.0.0#type-extractablefilematcher
5 | export function isFile (value) {
6 | return value instanceof UploadWithOptions || value instanceof fs.ReadStream || value instanceof Buffer
7 | }
8 |
9 | export function graphQLUploadSchemaIsValid (schema, parent, key) {
10 | // schema is null or undefined
11 | if (schema == null) {
12 | return true
13 | }
14 |
15 | if (key !== 'file') {
16 | if (schema instanceof Array) {
17 | return schema.every((subSchema) => graphQLUploadSchemaIsValid(subSchema, schema))
18 | }
19 |
20 | if (schema.constructor.name === 'Object') {
21 | return Object.entries(schema).every(([key, subSchema]) => graphQLUploadSchemaIsValid(subSchema, schema, key))
22 | }
23 |
24 | return !isFile(schema)
25 | }
26 |
27 | // OK, the key is 'file'
28 |
29 | // All flavors should be nested, and not top-level
30 | if (!(parent && parent.file === schema)) {
31 | return false
32 | }
33 |
34 | // Base64 Upload
35 | if (schema.data) {
36 | // Must be a string and also have the provided keys
37 | return (
38 | typeof schema.data === 'string' &&
39 | ['filename', 'mimetype'].every((requiredKey) => schema[requiredKey])
40 | )
41 | }
42 |
43 | return isFile(schema)
44 | }
45 |
--------------------------------------------------------------------------------
/test/.eslintrc.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | extends: '../.eslintrc.js',
3 | env: {
4 | mocha: true,
5 | },
6 | globals: {
7 | expect: 'readonly',
8 | should: 'readonly',
9 | sinon: 'readonly',
10 | mount: 'readonly',
11 | render: 'readonly',
12 | shallow: 'readonly',
13 | //* ************************************************
14 | // bdd-lazy-var
15 | //
16 | // In order to get around eslint complaining for now:
17 | // https://github.com/stalniy/bdd-lazy-var/issues/56#issuecomment-639248242
18 | $: 'readonly',
19 | its: 'readonly',
20 | def: 'readonly',
21 | subject: 'readonly',
22 | get: 'readonly',
23 | sharedExamplesFor: 'readonly',
24 | includeExamplesFor: 'readonly',
25 | itBehavesLike: 'readonly',
26 | is: 'readonly',
27 | //
28 | //* ************************************************
29 | },
30 | }
31 |
--------------------------------------------------------------------------------
/test/assets/dummy.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/anvilco/node-anvil/ff56ea27765f50ddc0d4fdfb22e2d9fa40bf51bb/test/assets/dummy.pdf
--------------------------------------------------------------------------------
/test/e2e/.gitignore:
--------------------------------------------------------------------------------
1 | *.tgz
2 | node_modules
3 | yarn.lock
4 | package-lock.json
5 |
--------------------------------------------------------------------------------
/test/e2e/node-anvil.tgz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/anvilco/node-anvil/ff56ea27765f50ddc0d4fdfb22e2d9fa40bf51bb/test/e2e/node-anvil.tgz
--------------------------------------------------------------------------------
/test/e2e/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "e2e",
3 | "version": "1.0.0",
4 | "description": "e2e tester",
5 | "main": "index.js",
6 | "scripts": {
7 | "prep": "npm run clean-cache && yarn remove-files",
8 | "remove-files": "rm -rf yarn.lock node_modules/node-anvil",
9 | "clean-cache": "rm -rf $(yarn cache dir)/.tmp"
10 | },
11 | "author": "",
12 | "license": "ISC",
13 | "dependencies": {
14 | "node-anvil": "file:node-anvil.tgz"
15 | }
16 | }
17 |
--------------------------------------------------------------------------------
/test/environment.js:
--------------------------------------------------------------------------------
1 | const sinon = require('sinon')
2 | const chai = require('chai')
3 | const sinonChai = require('sinon-chai')
4 | const chaiAsPromised = require('chai-as-promised')
5 |
6 | chai.use(sinonChai)
7 | chai.use(chaiAsPromised)
8 |
9 | global.chai = chai
10 | global.sinon = sinon
11 | global.expect = chai.expect
12 | global.should = chai.should()
13 |
--------------------------------------------------------------------------------
/test/index.test.js:
--------------------------------------------------------------------------------
1 | import fs from 'fs'
2 | import path from 'path'
3 |
4 | import { RateLimiter } from 'limiter'
5 | import { AbortSignal } from 'abort-controller'
6 |
7 | import Anvil from '../index'
8 |
9 | const assetsDir = path.join(__dirname, 'assets')
10 |
11 | function mockNodeFetchResponse (options = {}) {
12 | const { headers: headersIn = {}, ...rest } = options
13 | const {
14 | status,
15 | statusText,
16 | json,
17 | buffer,
18 | arrayBuffer,
19 | headers = {
20 | 'x-ratelimit-limit': 1,
21 | 'x-ratelimit-interval-ms': 1000,
22 | ...headersIn,
23 | },
24 | body,
25 | } = rest
26 |
27 | const mock = {
28 | status,
29 | statusText: statusText || ((status && status >= 200 && status < 300) ? 'OK' : 'Please specify error statusText for testing'),
30 | }
31 |
32 | mock.json = typeof json === 'function' ? json : () => json
33 | if (json) {
34 | headers['content-type'] = 'application/json'
35 | }
36 |
37 | mock.buffer = typeof buffer === 'function' ? buffer : () => buffer instanceof Buffer ? buffer : Buffer.from(buffer)
38 | if (arrayBuffer) {
39 | mock.arrayBuffer = typeof buffer === 'function' ? arrayBuffer : () => arrayBuffer
40 | } else {
41 | mock.arrayBuffer = () => {
42 | const buffer = mock.buffer()
43 | const ab = new ArrayBuffer(buffer.length)
44 | const view = new Uint8Array(ab)
45 | for (let i = 0; i < buffer.length; ++i) {
46 | view[i] = buffer[i]
47 | }
48 | return ab
49 | }
50 | }
51 |
52 | mock.body = body
53 |
54 | mock.headers = {
55 | get: (header) => headers[header],
56 | }
57 |
58 | return mock
59 | }
60 |
61 | function fakeThrottle (fn) {
62 | return fn(() => fakeThrottle(fn))
63 | }
64 |
65 | let FormDataModule
66 |
67 | describe('Anvil API Client', function () {
68 | before(async function () {
69 | FormDataModule ??= await import('formdata-polyfill/esm.min.js')
70 | })
71 |
72 | beforeEach(function () {
73 | sinon.stub(Anvil.prototype, '_throttle').callsFake(fakeThrottle)
74 | })
75 | afterEach(function () {
76 | sinon.restore()
77 | })
78 |
79 | describe('constructor', function () {
80 | it('throws an error when no options specified', async function () {
81 | expect(() => new Anvil()).to.throw('options are required')
82 | })
83 |
84 | it('throws an error when no apiKey or accessToken specified', async function () {
85 | expect(() => new Anvil({})).to.throw('apiKey or accessToken required')
86 | })
87 |
88 | it('builds a Basic auth header when apiKey passed in', async function () {
89 | const apiKey = 'abc123'
90 | const client = new Anvil({ apiKey })
91 | expect(client.authHeader).to.equal(`Basic ${Buffer.from(`${apiKey}:`, 'ascii').toString('base64')}`)
92 | })
93 |
94 | it('builds a Bearer auth header when accessToken passed in', async function () {
95 | const accessToken = 'def345'
96 | const client = new Anvil({ accessToken })
97 | expect(client.authHeader).to.equal(`Bearer ${Buffer.from(accessToken, 'ascii').toString('base64')}`)
98 | })
99 | })
100 |
101 | describe('REST endpoints', function () {
102 | let client
103 |
104 | beforeEach(async function () {
105 | client = new Anvil({ apiKey: 'abc123' })
106 | sinon.stub(client, '_request')
107 | })
108 |
109 | describe('requestREST', function () {
110 | let options, clientOptions, data, result
111 |
112 | it('returns statusCode and data when specified', async function () {
113 | options = {
114 | method: 'POST',
115 | }
116 | clientOptions = {
117 | dataType: 'json',
118 | }
119 | data = { result: 'ok' }
120 |
121 | client._request.callsFake((url, options) => {
122 | return Promise.resolve(
123 | mockNodeFetchResponse({
124 | status: 200,
125 | json: data,
126 | headers: { 'content-type': 'application/json' },
127 | }),
128 | )
129 | })
130 | const result = await client.requestREST('/test', options, clientOptions)
131 |
132 | expect(client._request).to.have.been.calledOnce
133 | expect(result.statusCode).to.eql(200)
134 | expect(result.data).to.eql(data)
135 | })
136 |
137 | it('rejects promise when error', async function () {
138 | options = { method: 'POST' }
139 |
140 | client._request.callsFake((url, options) => {
141 | throw new Error('problem')
142 | })
143 |
144 | await expect(client.requestREST('/test', options)).to.eventually.have.been.rejectedWith('problem')
145 | })
146 |
147 | it('handles various error response structures', async function () {
148 | options = {
149 | method: 'GET',
150 | }
151 | clientOptions = {
152 | dataType: 'json',
153 | }
154 |
155 | const errors = [
156 | {
157 | name: 'AssertionError',
158 | message: 'PDF did not generate properly from given HTML!',
159 | },
160 | {
161 | name: 'ValidationError',
162 | fields: [{ message: 'Required', property: 'data' }],
163 | },
164 | ]
165 |
166 | for (const error of errors) {
167 | client._request.callsFake((url, options) => {
168 | return Promise.resolve(
169 | mockNodeFetchResponse({
170 | // Some calls (like those to GraphQL) will return 200 / OKs but actually contain
171 | // errors
172 | status: 200,
173 | statusText: 'OK',
174 | json: () => error,
175 | headers: { 'content-type': 'application/json' },
176 | }),
177 | )
178 | })
179 |
180 | const result = await client.requestREST('/some-endpoint', options, clientOptions)
181 | expect(result.statusCode).to.eql(200)
182 | expect(result.errors).to.eql([error])
183 | }
184 | })
185 |
186 | it('recovers when JSON parsing of error response fails AND gives default error structure', async function () {
187 | options = {
188 | method: 'GET',
189 | }
190 | clientOptions = {
191 | dataType: 'json',
192 | }
193 |
194 | client._request.callsFake((url, options) => {
195 | return Promise.resolve(
196 | mockNodeFetchResponse({
197 | status: 404,
198 | statusText: 'Not Found',
199 | json: () => JSON.parse('will not parse'),
200 | }),
201 | )
202 | })
203 |
204 | const result = await client.requestREST('/non-existing-endpoint', options, clientOptions)
205 | expect(result.statusCode).to.eql(404)
206 | expect(result.errors).to.be.an('array').of.length(1)
207 | expect(result.errors[0]).to.include({
208 | name: 'SyntaxError',
209 | message: 'Unexpected token w in JSON at position 0',
210 | code: undefined,
211 | cause: undefined,
212 | })
213 | })
214 |
215 | it('sets the rate limiter from the response headers', async function () {
216 | // Originally, these are true
217 | expect(client.hasSetLimiterFromResponse).to.eql(false)
218 | expect(client.limiterSettingInProgress).to.eql(false)
219 | expect(client.rateLimiterSetupPromise).to.be.an.instanceof(Promise)
220 | expect(client.limitTokens).to.eql(1)
221 | expect(client.limitIntervalMs).to.eql(1000)
222 | expect(client.limiter).to.be.an.instanceof(RateLimiter)
223 |
224 | client._request.callsFake((url, options) => {
225 | return Promise.resolve(
226 | mockNodeFetchResponse({
227 | status: 200,
228 | json: data,
229 | headers: {
230 | 'x-ratelimit-limit': 42,
231 | 'x-ratelimit-interval-ms': 4200,
232 | },
233 | }),
234 | )
235 | })
236 |
237 | const result = await client.requestREST('/test', options, clientOptions)
238 |
239 | // Afterwards, these are true
240 | expect(client._request).to.have.been.calledOnce
241 | expect(result.statusCode).to.eql(200)
242 | expect(result.data).to.eql(data)
243 |
244 | expect(client.hasSetLimiterFromResponse).to.eql(true)
245 | expect(client.limitTokens).to.eql(42)
246 | expect(client.limitIntervalMs).to.eql(4200)
247 | expect(client.limiter).to.be.an.instanceof(RateLimiter)
248 | })
249 |
250 | it('retries when a 429 response', async function () {
251 | options = { method: 'POST' }
252 | clientOptions = { dataType: 'json' }
253 | data = { result: 'ok' }
254 |
255 | client._request.onCall(0).callsFake((url, options) => {
256 | return Promise.resolve(
257 | mockNodeFetchResponse({
258 | status: 429,
259 | headers: {
260 | 'retry-after': '0.2', // in seconds
261 | },
262 | }),
263 | )
264 | })
265 |
266 | client._request.onCall(1).callsFake((url, options) => {
267 | return Promise.resolve(
268 | mockNodeFetchResponse({
269 | status: 200,
270 | json: data,
271 | }),
272 | )
273 | })
274 |
275 | result = await client.requestREST('/test', options, clientOptions)
276 |
277 | expect(client._request).to.have.been.calledTwice
278 | expect(result.statusCode).to.eql(200)
279 | expect(result.data).to.eql(data)
280 | })
281 | })
282 |
283 | describe('fillPDF', function () {
284 | def('statusCode', 200)
285 |
286 | beforeEach(async function () {
287 | client._request.callsFake((url, options) => {
288 | return Promise.resolve(
289 | mockNodeFetchResponse({
290 | status: $.statusCode,
291 | buffer: $.buffer,
292 | json: $.json,
293 | }),
294 | )
295 | })
296 | })
297 |
298 | context('everything goes well', function () {
299 | def('buffer', 'This would be PDF data...')
300 | def('payload', {
301 | title: 'Test',
302 | fontSize: 8,
303 | textColor: '#CC0000',
304 | data: {
305 | helloId: 'hello!',
306 | },
307 | })
308 |
309 | it('returns data', async function () {
310 | const payload = $.payload
311 | const result = await client.fillPDF('cast123', payload)
312 |
313 | expect(result.statusCode).to.eql(200)
314 | expect(result.data.toString()).to.eql('This would be PDF data...')
315 |
316 | expect(client._request).to.have.been.calledOnce
317 |
318 | const [url, options] = client._request.lastCall.args
319 | expect(url).to.eql('/api/v1/fill/cast123.pdf')
320 | expect(options).to.eql({
321 | method: 'POST',
322 | body: JSON.stringify(payload),
323 | headers: {
324 | 'Content-Type': 'application/json',
325 | },
326 | })
327 | })
328 |
329 | it('works with `versionNumber`', async function () {
330 | const payload = $.payload
331 | const result = await client.fillPDF('cast123', payload, { versionNumber: 5 })
332 |
333 | expect(result.statusCode).to.eql(200)
334 | expect(result.data.toString()).to.eql('This would be PDF data...')
335 |
336 | expect(client._request).to.have.been.calledOnce
337 |
338 | const [url, options] = client._request.lastCall.args
339 | expect(url).to.eql('/api/v1/fill/cast123.pdf?versionNumber=5')
340 | expect(options).to.eql({
341 | method: 'POST',
342 | body: JSON.stringify(payload),
343 | headers: {
344 | 'Content-Type': 'application/json',
345 | },
346 | })
347 | })
348 | })
349 |
350 | context('server 400s with errors array in JSON', function () {
351 | const errors = [{ message: 'problem' }]
352 | def('statusCode', 400)
353 | def('json', { errors })
354 |
355 | it('finds errors and puts them in response', async function () {
356 | const result = await client.fillPDF('cast123', {})
357 |
358 | expect(client._request).to.have.been.calledOnce
359 | expect(result.statusCode).to.eql(400)
360 | expect(result.errors).to.eql(errors)
361 | })
362 | })
363 |
364 | context('server 401s with single error in response', function () {
365 | const error = { name: 'AuthorizationError', message: 'problem' }
366 | def('statusCode', 401)
367 | def('json', error)
368 |
369 | it('finds error and puts it in the response', async function () {
370 | const result = await client.fillPDF('cast123', {})
371 |
372 | expect(client._request).to.have.been.calledOnce
373 | expect(result.statusCode).to.eql(401)
374 | expect(result.errors).to.eql([error])
375 | })
376 | })
377 | })
378 |
379 | describe('generatePDF', function () {
380 | def('statusCode', 200)
381 |
382 | beforeEach(async function () {
383 | client._request.callsFake((url, options) => {
384 | return Promise.resolve(
385 | mockNodeFetchResponse({
386 | status: $.statusCode,
387 | buffer: $.buffer,
388 | json: $.json,
389 | }),
390 | )
391 | })
392 | })
393 |
394 | context('everything goes well', function () {
395 | def('buffer', 'This would be PDF data...')
396 |
397 | it('returns data', async function () {
398 | const payload = {
399 | title: 'Test',
400 | data: [{
401 | label: 'hello!',
402 | }],
403 | }
404 |
405 | const result = await client.generatePDF(payload)
406 |
407 | expect(result.statusCode).to.eql(200)
408 | expect(result.data.toString()).to.eql('This would be PDF data...')
409 |
410 | expect(client._request).to.have.been.calledOnce
411 |
412 | const [url, options] = client._request.lastCall.args
413 | expect(url).to.eql('/api/v1/generate-pdf')
414 | expect(options).to.eql({
415 | method: 'POST',
416 | body: JSON.stringify(payload),
417 | headers: {
418 | 'Content-Type': 'application/json',
419 | },
420 | })
421 | })
422 | })
423 |
424 | context('server 400s with errors array in JSON', function () {
425 | const errors = [{ message: 'problem' }]
426 | def('statusCode', 400)
427 | def('json', { errors })
428 |
429 | it('finds errors and puts them in response', async function () {
430 | const result = await client.generatePDF('cast123', {})
431 |
432 | expect(client._request).to.have.been.calledOnce
433 | expect(result.statusCode).to.eql(400)
434 | expect(result.errors).to.eql(errors)
435 | })
436 | })
437 |
438 | context('server 401s with single error in response', function () {
439 | const error = { name: 'AuthorizationError', message: 'Not logged in.' }
440 | def('statusCode', 401)
441 | def('json', error)
442 |
443 | it('finds error and puts it in the response', async function () {
444 | const result = await client.generatePDF('cast123', {})
445 |
446 | expect(client._request).to.have.been.calledOnce
447 | expect(result.statusCode).to.eql(401)
448 | expect(result.errors).to.eql([error])
449 | })
450 | })
451 | })
452 |
453 | describe('downloadDocuments', function () {
454 | def('statusCode', 200)
455 | def('buffer', 'This would be Zip file data buffer...')
456 | def('body', 'This would be Zip file data stream')
457 | def('nodeFetchResponse', () => mockNodeFetchResponse({
458 | status: $.statusCode,
459 | buffer: $.buffer,
460 | body: $.body,
461 | json: $.json,
462 | }))
463 |
464 | beforeEach(async function () {
465 | client._request.callsFake((url, options) => {
466 | return Promise.resolve($.nodeFetchResponse)
467 | })
468 | })
469 |
470 | context('everything goes well', function () {
471 | it('returns data as buffer', async function () {
472 | const { statusCode, response, data, errors } = await client.downloadDocuments('docGroupEid123')
473 | expect(data).to.be.an.instanceOf(Buffer)
474 | expect(statusCode).to.eql(200)
475 | expect(response).to.deep.eql($.nodeFetchResponse)
476 | expect(data.toString()).to.eql($.buffer)
477 | expect(errors).to.be.undefined
478 | })
479 |
480 | it('returns data asn arrayBuffer', async function () {
481 | const { statusCode, response, data, errors } = await client.downloadDocuments('docGroupEid123', { dataType: 'arrayBuffer' })
482 | expect(data).to.be.an.instanceOf(ArrayBuffer)
483 | expect(statusCode).to.eql(200)
484 | expect(response).to.deep.eql($.nodeFetchResponse)
485 | expect(Buffer.from(data).toString()).to.eql($.buffer)
486 | expect(errors).to.be.undefined
487 | })
488 |
489 | it('returns data as stream', async function () {
490 | const { statusCode, response, data, errors } = await client.downloadDocuments('docGroupEid123', { dataType: 'stream' })
491 | expect(statusCode).to.eql(200)
492 | expect(response).to.deep.eql($.nodeFetchResponse)
493 | expect(data).to.eql($.body)
494 | expect(errors).to.be.undefined
495 | })
496 | })
497 |
498 | context('unsupported options', function () {
499 | it('raises appropriate error', async function () {
500 | try {
501 | await client.downloadDocuments('docGroupEid123', { dataType: 'json' })
502 | } catch (e) {
503 | expect(e.message).to.eql('dataType must be one of: stream|buffer|arrayBuffer')
504 | }
505 | })
506 | })
507 |
508 | context('server 400s with errors array in JSON', function () {
509 | const errors = [{ message: 'problem' }]
510 | def('statusCode', 400)
511 | def('json', { errors })
512 |
513 | it('finds errors and puts them in response', async function () {
514 | const { statusCode, errors } = await client.downloadDocuments('docGroupEid123')
515 |
516 | expect(client._request).to.have.been.calledOnce
517 | expect(statusCode).to.eql(400)
518 | expect(errors).to.eql(errors)
519 | })
520 | })
521 |
522 | context('server 401s with single error in response', function () {
523 | const error = { name: 'AuthorizationError', message: 'problem' }
524 | def('statusCode', 401)
525 | def('json', error)
526 |
527 | it('finds error and puts it in the response', async function () {
528 | const { statusCode, errors } = await client.downloadDocuments('docGroupEid123')
529 |
530 | expect(client._request).to.have.been.calledOnce
531 | expect(statusCode).to.eql(401)
532 | expect(errors).to.eql([error])
533 | })
534 | })
535 | })
536 | })
537 |
538 | describe('GraphQL', function () {
539 | const client = new Anvil({ apiKey: 'abc123' })
540 |
541 | describe('requestGraphQL', function () {
542 | beforeEach(function () {
543 | sinon.stub(client, '_wrapRequest')
544 | client._wrapRequest.callsFake(async () => ({}))
545 | sinon.stub(client, '_request')
546 | })
547 |
548 | describe('without files', function () {
549 | it('stringifies query and variables', async function () {
550 | const query = { foo: 'bar' }
551 | const variables = { baz: 'bop' }
552 | const clientOptions = { yo: 'mtvRaps' }
553 |
554 | await client.requestGraphQL({ query, variables }, clientOptions)
555 |
556 | expect(client._wrapRequest).to.have.been.calledOnce
557 |
558 | const [fn, clientOptionsReceived] = client._wrapRequest.lastCall.args
559 | expect(clientOptions).to.eql(clientOptionsReceived)
560 |
561 | fn()
562 |
563 | expect(client._request).to.have.been.calledOnce
564 | const [, options] = client._request.lastCall.args
565 | const {
566 | method,
567 | headers,
568 | body,
569 | } = options
570 |
571 | expect(method).to.eql('POST')
572 | expect(headers).to.eql({ 'Content-Type': 'application/json' })
573 | expect(body).to.eql(JSON.stringify({ query, variables }))
574 | })
575 | })
576 |
577 | describe('with files', function () {
578 | beforeEach(function () {
579 | sinon.spy(FormDataModule.FormData.prototype, 'append')
580 | })
581 |
582 | describe('schema is good', function () {
583 | const query = { foo: 'bar', baz: null }
584 | const clientOptions = { yo: 'mtvRaps' }
585 |
586 | afterEach(function () {
587 | if ($.willFail) {
588 | expect(client._wrapRequest).to.not.have.been.called
589 | return
590 | }
591 |
592 | expect(client._wrapRequest).to.have.been.calledOnce
593 |
594 | const [fn, clientOptionsReceived] = client._wrapRequest.lastCall.args
595 | expect(clientOptions).to.eql(clientOptionsReceived)
596 |
597 | fn()
598 |
599 | expect(client._request).to.have.been.calledOnce
600 | const [, options] = client._request.lastCall.args
601 |
602 | const {
603 | method,
604 | headers,
605 | body,
606 | signal,
607 | } = options
608 |
609 | expect(method).to.eql('POST')
610 | if ($.isBase64) {
611 | expect(headers).to.eql({
612 | 'Content-Type': 'application/json',
613 | })
614 | // Vars are untouched
615 | expect(JSON.parse(body).variables).to.eql($.variables)
616 | } else {
617 | expect(headers).to.eql({}) // node-fetch will add appropriate header
618 | expect(body).to.be.an.instanceof(FormDataModule.FormData)
619 | expect(signal).to.be.an.instanceof(AbortSignal)
620 | expect(
621 | FormDataModule.FormData.prototype.append.withArgs(
622 | 'map',
623 | JSON.stringify({ 1: ['variables.aNested.file'] }),
624 | ),
625 | ).calledOnce
626 | }
627 | })
628 |
629 | context('using a Buffer', function () {
630 | def('variables', () => ({
631 | aNested: {
632 | file: Anvil.prepareGraphQLFile(Buffer.from(''), { filename: 'test.pdf' }),
633 | },
634 | }))
635 |
636 | it('creates a FormData and appends the files map when prepareGraphQLFile was used', async function () {
637 | await client.requestGraphQL({ query, variables: $.variables }, clientOptions)
638 | })
639 |
640 | context('file is a Buffer', function () {
641 | def('willFail', () => true)
642 | def('variables', () => ({
643 | aNested: {
644 | file: Buffer.from(''),
645 | },
646 | }))
647 |
648 | it('throws an error creating a FormData and appending to the files map when a raw Buffer is used', async function () {
649 | await expect(client.requestGraphQL({ query, variables: $.variables }, clientOptions))
650 | .to.eventually.be.rejectedWith('When passing a Buffer to prepareGraphQLFile, `options.filename` must be provided')
651 | })
652 | })
653 | })
654 |
655 | context('file is a Stream', function () {
656 | def('variables', () => {
657 | const file = fs.createReadStream(path.join(assetsDir, 'dummy.pdf'))
658 | return {
659 | aNested: {
660 | file,
661 | },
662 | }
663 | })
664 |
665 | it('creates a FormData and appends the files map', async function () {
666 | await client.requestGraphQL({ query, variables: $.variables }, clientOptions)
667 | })
668 | })
669 |
670 | context('file is a base64 upload', function () {
671 | def('isBase64', () => true)
672 | def('variables', () => {
673 | return {
674 | aNested: {
675 | file: {
676 | data: Buffer.from('Base64 Data').toString('base64'),
677 | filename: 'omgwow.pdf',
678 | mimetype: 'application/pdf',
679 | },
680 | },
681 | }
682 | })
683 |
684 | it('does not touch the variables at all', async function () {
685 | await client.requestGraphQL({ query, variables: $.variables }, clientOptions)
686 | })
687 | })
688 | })
689 |
690 | describe('schema is not good', function () {
691 | context('file is not a stream or buffer', function () {
692 | it('throws error about the schema', async function () {
693 | const query = { foo: 'bar' }
694 | const variables = {
695 | file: 'i am not a file',
696 | }
697 |
698 | await expect(client.requestGraphQL({ query, variables })).to.eventually.be.rejectedWith('Invalid File schema detected')
699 | })
700 | })
701 | })
702 | })
703 | })
704 |
705 | describe('createEtchPacket', function () {
706 | beforeEach(function () {
707 | sinon.stub(client, 'requestGraphQL')
708 | })
709 |
710 | context('mutation is specified', function () {
711 | it('calls requestGraphQL with overridden mutation', async function () {
712 | const variables = { foo: 'bar' }
713 | const mutationOverride = 'createEtchPacketOverride()'
714 |
715 | await client.createEtchPacket({ variables, mutation: mutationOverride })
716 |
717 | expect(client.requestGraphQL).to.have.been.calledOnce
718 | const [options, clientOptions] = client.requestGraphQL.lastCall.args
719 |
720 | const {
721 | query,
722 | variables: variablesReceived,
723 | } = options
724 |
725 | expect(variables).to.eql(variablesReceived)
726 | expect(query).to.include(mutationOverride)
727 | expect(clientOptions).to.eql({ dataType: 'json' })
728 | })
729 | })
730 |
731 | context('no responseQuery specified', function () {
732 | it('calls requestGraphQL with default responseQuery', async function () {
733 | const variables = { foo: 'bar' }
734 |
735 | await client.createEtchPacket({ variables })
736 |
737 | expect(client.requestGraphQL).to.have.been.calledOnce
738 | const [options, clientOptions] = client.requestGraphQL.lastCall.args
739 |
740 | const {
741 | query,
742 | variables: variablesReceived,
743 | } = options
744 |
745 | expect(variables).to.eql(variablesReceived)
746 | expect(query).to.include('documentGroup {') // "documentGroup" is in the default responseQuery
747 | expect(clientOptions).to.eql({ dataType: 'json' })
748 | })
749 | })
750 |
751 | context('responseQuery specified', function () {
752 | it('calls requestGraphQL with overridden responseQuery', async function () {
753 | const variables = { foo: 'bar' }
754 | const responseQuery = 'onlyInATest {}'
755 |
756 | await client.createEtchPacket({ variables, responseQuery })
757 |
758 | expect(client.requestGraphQL).to.have.been.calledOnce
759 | const [options, clientOptions] = client.requestGraphQL.lastCall.args
760 |
761 | const {
762 | query,
763 | variables: variablesReceived,
764 | } = options
765 |
766 | expect(variables).to.eql(variablesReceived)
767 | expect(query).to.include(responseQuery)
768 | expect(clientOptions).to.eql({ dataType: 'json' })
769 | })
770 | })
771 | })
772 |
773 | describe('generateEtchSignUrl', function () {
774 | def('statusCode', 200)
775 | beforeEach(async function () {
776 | sinon.stub(client, '_request')
777 | client._request.callsFake((url, options) => {
778 | return Promise.resolve($.nodeFetchResponse)
779 | })
780 | })
781 |
782 | context('everything goes well', function () {
783 | def('data', {
784 | data: {
785 | generateEtchSignURL: 'http://www.testing.com',
786 | },
787 | })
788 | def('nodeFetchResponse', () => mockNodeFetchResponse({
789 | status: $.statusCode,
790 | json: $.data,
791 | }))
792 |
793 | it('returns url successfully', async function () {
794 | const variables = { clientUserId: 'foo', signerEid: 'bar' }
795 | const { statusCode, url, errors } = await client.generateEtchSignUrl({ variables })
796 | expect(statusCode).to.eql(200)
797 | expect(url).to.be.eql($.data.data.generateEtchSignURL)
798 | expect(errors).to.be.undefined
799 | })
800 | })
801 |
802 | context('generate URL failures', function () {
803 | def('data', {
804 | data: {},
805 | })
806 | def('nodeFetchResponse', () => mockNodeFetchResponse({
807 | status: $.statusCode,
808 | json: $.data,
809 | }))
810 |
811 | it('returns undefined url', async function () {
812 | const variables = { clientUserId: 'foo', signerEid: 'bar' }
813 | const { statusCode, url, errors } = await client.generateEtchSignUrl({ variables })
814 | expect(statusCode).to.eql(200)
815 | expect(url).to.be.undefined
816 | expect(errors).to.be.undefined
817 | })
818 | })
819 | })
820 |
821 | describe('getEtchPacket', function () {
822 | def('variables', { eid: 'etchPacketEid123' })
823 | beforeEach(function () {
824 | sinon.stub(client, 'requestGraphQL')
825 | })
826 |
827 | context('no responseQuery specified', function () {
828 | it('calls requestGraphQL with default responseQuery', async function () {
829 | await client.getEtchPacket({ variables: $.variables })
830 |
831 | expect(client.requestGraphQL).to.have.been.calledOnce
832 | const [options, clientOptions] = client.requestGraphQL.lastCall.args
833 |
834 | const {
835 | query,
836 | variables: variablesReceived,
837 | } = options
838 |
839 | expect($.variables).to.eql(variablesReceived)
840 | expect(query).to.include('documentGroup {')
841 | expect(clientOptions).to.eql({ dataType: 'json' })
842 | })
843 | })
844 |
845 | context('responseQuery specified', function () {
846 | it('calls requestGraphQL with overridden responseQuery', async function () {
847 | const responseQuery = 'myCustomResponseQuery'
848 | await client.getEtchPacket({ variables: $.variables, responseQuery })
849 |
850 | expect(client.requestGraphQL).to.have.been.calledOnce
851 | const [options, clientOptions] = client.requestGraphQL.lastCall.args
852 |
853 | const {
854 | query,
855 | variables: variablesReceived,
856 | } = options
857 |
858 | expect($.variables).to.eql(variablesReceived)
859 | expect(query).to.include(responseQuery)
860 | expect(clientOptions).to.eql({ dataType: 'json' })
861 | })
862 | })
863 | })
864 |
865 | describe('forgeSubmit', function () {
866 | beforeEach(function () {
867 | sinon.stub(client, 'requestGraphQL')
868 | })
869 |
870 | it('calls requestGraphQL with overridden mutation', async function () {
871 | const variables = { foo: 'bar' }
872 | const mutationOverride = 'forgeSubmitOverride()'
873 |
874 | await client.forgeSubmit({ variables, mutation: mutationOverride })
875 |
876 | expect(client.requestGraphQL).to.have.been.calledOnce
877 | const [options, clientOptions] = client.requestGraphQL.lastCall.args
878 |
879 | const {
880 | query,
881 | variables: variablesReceived,
882 | } = options
883 |
884 | expect(variables).to.eql(variablesReceived)
885 | expect(query).to.include(mutationOverride)
886 | expect(clientOptions).to.eql({ dataType: 'json' })
887 | })
888 |
889 | it('calls requestGraphQL with default responseQuery', async function () {
890 | const variables = { foo: 'bar' }
891 | await client.forgeSubmit({ variables })
892 |
893 | expect(client.requestGraphQL).to.have.been.calledOnce
894 | const [options, clientOptions] = client.requestGraphQL.lastCall.args
895 |
896 | const {
897 | query,
898 | variables: variablesReceived,
899 | } = options
900 |
901 | expect(variables).to.eql(variablesReceived)
902 | expect(query).to.include('signer {')
903 | expect(clientOptions).to.eql({ dataType: 'json' })
904 | })
905 |
906 | it('calls requestGraphQL with overridden responseQuery', async function () {
907 | const variables = { foo: 'bar' }
908 | const customResponseQuery = 'myCustomResponseQuery'
909 | await client.forgeSubmit({ variables, responseQuery: customResponseQuery })
910 |
911 | expect(client.requestGraphQL).to.have.been.calledOnce
912 | const [options, clientOptions] = client.requestGraphQL.lastCall.args
913 |
914 | const {
915 | query,
916 | variables: variablesReceived,
917 | } = options
918 |
919 | expect(variables).to.eql(variablesReceived)
920 | expect(query).to.include(customResponseQuery)
921 | expect(clientOptions).to.eql({ dataType: 'json' })
922 | })
923 | })
924 |
925 | describe('removeWeldData', function () {
926 | beforeEach(function () {
927 | sinon.stub(client, 'requestGraphQL')
928 | })
929 |
930 | it('calls requestGraphQL with overridden mutation', async function () {
931 | const variables = { foo: 'bar' }
932 | const mutationOverride = 'removeWeldDataOverride()'
933 |
934 | await client.removeWeldData({ variables, mutation: mutationOverride })
935 |
936 | expect(client.requestGraphQL).to.have.been.calledOnce
937 | const [options, clientOptions] = client.requestGraphQL.lastCall.args
938 |
939 | const {
940 | query,
941 | variables: variablesReceived,
942 | } = options
943 |
944 | expect(variables).to.eql(variablesReceived)
945 | expect(query).to.include(mutationOverride)
946 | expect(clientOptions).to.eql({ dataType: 'json' })
947 | })
948 | })
949 | })
950 |
951 | describe('prepareGraphQLFile', function () {
952 | it('works', function () {
953 | expect(() =>
954 | Anvil.prepareGraphQLFile(Buffer.from('test')),
955 | ).to.throw('When passing a Buffer to prepareGraphQLFile, `options.filename` must be provided. If you think you can ignore this, please pass `options.ignoreFilenameValidation` as `true`.')
956 |
957 | let uploadWithOptions = Anvil.prepareGraphQLFile(Buffer.from('test'), { ignoreFilenameValidation: true })
958 | expect(uploadWithOptions).to.be.ok
959 | expect(uploadWithOptions.streamLikeThing).to.be.ok
960 | expect(uploadWithOptions.formDataAppendOptions).to.eql({})
961 |
962 | uploadWithOptions = Anvil.prepareGraphQLFile(Buffer.from('test'), { filename: 'test.pdf' })
963 | expect(uploadWithOptions).to.be.ok
964 | expect(uploadWithOptions.streamLikeThing).to.be.ok
965 | expect(uploadWithOptions.formDataAppendOptions).to.include({
966 | filename: 'test.pdf',
967 | })
968 | })
969 | })
970 | })
971 |
--------------------------------------------------------------------------------
/test/mocha.js:
--------------------------------------------------------------------------------
1 | 'use strict'
2 |
3 | module.exports = {
4 | diff: true,
5 | delay: false,
6 | extension: ['js'],
7 | package: './package.json',
8 | reporter: 'spec',
9 | slow: 75,
10 | timeout: 2000,
11 | spec: './test/**/*.test.js',
12 | // Silly, Mocha. Don't run all the tests you can find...
13 | ignore: './test/**/node_modules/**/*',
14 | require: [
15 | // https://mochajs.org/#-require-module-r-module
16 | '@babel/register',
17 | './test/environment.js',
18 | ],
19 | file: './test/setup.js',
20 | ui: 'bdd-lazy-var/getter',
21 | exit: true,
22 | }
23 |
--------------------------------------------------------------------------------
/test/setup.js:
--------------------------------------------------------------------------------
1 | const { get } = require('bdd-lazy-var/getter')
2 |
3 | // In order to get around eslint complaining for now:
4 | // https://github.com/stalniy/bdd-lazy-var/issues/56#issuecomment-639248242
5 | global.$ = get
6 |
--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | // Change this to match your project
3 | "include": [
4 | "src/**/*"
5 | ],
6 | "compilerOptions": {
7 | "module": "node16",
8 | "moduleResolution": "node16",
9 | "noImplicitThis": true,
10 | "alwaysStrict": true,
11 | "checkJs": true,
12 | "resolveJsonModule": true,
13 | // Tells TypeScript to read JS files, as
14 | // normally they are ignored as source files
15 | "allowJs": true,
16 | // Generate d.ts files
17 | "declaration": true,
18 | // This compiler run should
19 | // only output d.ts files
20 | "emitDeclarationOnly": true,
21 | // Types should go into this directory.
22 | // Removing this would place the .d.ts files
23 | // next to the .js files
24 | "outDir": "types",
25 | // go to js file when using IDE functions like
26 | // "Go to Definition" in VSCode
27 | "declarationMap": true
28 | }
29 | }
30 |
--------------------------------------------------------------------------------
/types/src/UploadWithOptions.d.ts:
--------------------------------------------------------------------------------
1 | export default class UploadWithOptions {
2 | constructor(streamLikeThing: any, formDataAppendOptions: any);
3 | streamLikeThing: any;
4 | formDataAppendOptions: any;
5 | get options(): any;
6 | get file(): any;
7 | }
8 | //# sourceMappingURL=UploadWithOptions.d.ts.map
--------------------------------------------------------------------------------
/types/src/UploadWithOptions.d.ts.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"UploadWithOptions.d.ts","sourceRoot":"","sources":["../../src/UploadWithOptions.js"],"names":[],"mappings":"AAAA;IACE,8DAGC;IAFC,qBAAsC;IACtC,2BAAkD;IAGpD,mBAEC;IAED,gBAEC;CACF"}
--------------------------------------------------------------------------------
/types/src/errors.d.ts:
--------------------------------------------------------------------------------
1 | export function looksLikeJsonError({ json }: {
2 | json: any;
3 | }): boolean;
4 | export function normalizeJsonErrors({ json, statusText }: {
5 | json: any;
6 | statusText?: string;
7 | }): any;
8 | export function normalizeNodeError({ error, statusText }: {
9 | error: any;
10 | statusText?: string;
11 | }): {
12 | name: any;
13 | message: any;
14 | code: any;
15 | cause: any;
16 | stack: any;
17 | }[] | {
18 | name: string;
19 | message: string;
20 | }[];
21 | //# sourceMappingURL=errors.d.ts.map
--------------------------------------------------------------------------------
/types/src/errors.d.ts.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.js"],"names":[],"mappings":"AACA;;YAEC;AAGD;;;QA0BC;AAGD;;;;;;;;;;;;IAOC"}
--------------------------------------------------------------------------------
/types/src/graphql/index.d.ts:
--------------------------------------------------------------------------------
1 | export * as queries from "./queries";
2 | export * as mutations from "./mutations";
3 | //# sourceMappingURL=index.d.ts.map
--------------------------------------------------------------------------------
/types/src/graphql/index.d.ts.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/graphql/index.js"],"names":[],"mappings":""}
--------------------------------------------------------------------------------
/types/src/graphql/mutations/createEtchPacket.d.ts:
--------------------------------------------------------------------------------
1 | export function generateMutation(responseQuery?: string): string;
2 | //# sourceMappingURL=createEtchPacket.d.ts.map
--------------------------------------------------------------------------------
/types/src/graphql/mutations/createEtchPacket.d.ts.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"createEtchPacket.d.ts","sourceRoot":"","sources":["../../../../src/graphql/mutations/createEtchPacket.js"],"names":[],"mappings":"AA4BO,iEAyCH"}
--------------------------------------------------------------------------------
/types/src/graphql/mutations/forgeSubmit.d.ts:
--------------------------------------------------------------------------------
1 | export function generateMutation(responseQuery?: string): string;
2 | //# sourceMappingURL=forgeSubmit.d.ts.map
--------------------------------------------------------------------------------
/types/src/graphql/mutations/forgeSubmit.d.ts.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"forgeSubmit.d.ts","sourceRoot":"","sources":["../../../../src/graphql/mutations/forgeSubmit.js"],"names":[],"mappings":"AAyBO,iEA6BH"}
--------------------------------------------------------------------------------
/types/src/graphql/mutations/generateEtchSignUrl.d.ts:
--------------------------------------------------------------------------------
1 | export function generateMutation(): string;
2 | //# sourceMappingURL=generateEtchSignUrl.d.ts.map
--------------------------------------------------------------------------------
/types/src/graphql/mutations/generateEtchSignUrl.d.ts.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"generateEtchSignUrl.d.ts","sourceRoot":"","sources":["../../../../src/graphql/mutations/generateEtchSignUrl.js"],"names":[],"mappings":"AAAO,2CAUN"}
--------------------------------------------------------------------------------
/types/src/graphql/mutations/index.d.ts:
--------------------------------------------------------------------------------
1 | export * as createEtchPacket from "./createEtchPacket";
2 | export * as forgeSubmit from "./forgeSubmit";
3 | export * as generateEtchSignUrl from "./generateEtchSignUrl";
4 | export * as removeWeldData from "./removeWeldData";
5 | //# sourceMappingURL=index.d.ts.map
--------------------------------------------------------------------------------
/types/src/graphql/mutations/index.d.ts.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/graphql/mutations/index.js"],"names":[],"mappings":""}
--------------------------------------------------------------------------------
/types/src/graphql/mutations/removeWeldData.d.ts:
--------------------------------------------------------------------------------
1 | export function generateMutation(): string;
2 | //# sourceMappingURL=removeWeldData.d.ts.map
--------------------------------------------------------------------------------
/types/src/graphql/mutations/removeWeldData.d.ts.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"removeWeldData.d.ts","sourceRoot":"","sources":["../../../../src/graphql/mutations/removeWeldData.js"],"names":[],"mappings":"AAAO,2CAOH"}
--------------------------------------------------------------------------------
/types/src/graphql/queries/etchPacket.d.ts:
--------------------------------------------------------------------------------
1 | export function generateQuery(responseQuery?: string): string;
2 | //# sourceMappingURL=etchPacket.d.ts.map
--------------------------------------------------------------------------------
/types/src/graphql/queries/etchPacket.d.ts.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"etchPacket.d.ts","sourceRoot":"","sources":["../../../../src/graphql/queries/etchPacket.js"],"names":[],"mappings":"AA+BO,8DAQN"}
--------------------------------------------------------------------------------
/types/src/graphql/queries/index.d.ts:
--------------------------------------------------------------------------------
1 | export * as etchPacket from "./etchPacket";
2 | //# sourceMappingURL=index.d.ts.map
--------------------------------------------------------------------------------
/types/src/graphql/queries/index.d.ts.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/graphql/queries/index.js"],"names":[],"mappings":""}
--------------------------------------------------------------------------------
/types/src/index.d.ts:
--------------------------------------------------------------------------------
1 | export default Anvil;
2 | export type AnvilOptions = {
3 | apiKey?: string;
4 | accessToken?: string;
5 | baseURL?: string;
6 | userAgent?: string;
7 | requestLimit?: number;
8 | requestLimitMS?: number;
9 | };
10 | export type GraphQLResponse = {
11 | statusCode: number;
12 | data?: GraphQLResponseData;
13 | errors?: Array;
14 | };
15 | export type GraphQLResponseData = {
16 | data: {
17 | [key: string]: any;
18 | };
19 | };
20 | export type RESTResponse = {
21 | statusCode: number;
22 | data?: Buffer | Stream | any;
23 | errors?: Array;
24 | /**
25 | * node-fetch Response
26 | */
27 | response?: any;
28 | };
29 | export type NodeError = {
30 | name: string;
31 | message: string;
32 | stack: string;
33 | code: string;
34 | cause?: any;
35 | };
36 | export type ResponseError = {
37 | [key: string]: any;
38 | message: string;
39 | status?: number;
40 | name?: string;
41 | fields?: Array;
42 | };
43 | export type ResponseErrorField = {
44 | [key: string]: any;
45 | message: string;
46 | property?: string;
47 | };
48 | export type Readable = {
49 | path: string;
50 | };
51 | declare class Anvil {
52 | /**
53 | * Perform some handy/necessary things for a GraphQL file upload to make it work
54 | * with this client and with our backend
55 | *
56 | * @param {string|Buffer|Readable|File|Blob} pathOrStreamLikeThing - Either a string path to a file,
57 | * a Buffer, or a Stream-like thing that is compatible with form-data as an append.
58 | * @param {Object} [formDataAppendOptions] - User can specify options to be passed to the form-data.append
59 | * call. This should be done if a stream-like thing is not one of the common types that
60 | * form-data can figure out on its own.
61 | *
62 | * @return {UploadWithOptions} - A class that wraps the stream-like-thing and any options
63 | * up together nicely in a way that we can also tell that it was us who did it.
64 | */
65 | static prepareGraphQLFile(pathOrStreamLikeThing: string | Buffer | Readable | File | Blob, { ignoreFilenameValidation, ...formDataAppendOptions }?: any): UploadWithOptions;
66 | /**
67 | * @param {AnvilOptions?} options
68 | */
69 | constructor(options: AnvilOptions | null);
70 | options: {
71 | apiKey?: string;
72 | accessToken?: string;
73 | baseURL: string;
74 | userAgent: string;
75 | requestLimit: number;
76 | requestLimitMS: number;
77 | };
78 | authHeader: string;
79 | hasSetLimiterFromResponse: boolean;
80 | limiterSettingInProgress: boolean;
81 | rateLimiterSetupPromise: Promise;
82 | rateLimiterPromiseResolver: (value: any) => void;
83 | /**
84 | * @param {Object} options
85 | * @param {number} options.tokens
86 | * @param {number} options.intervalMs
87 | * @private
88 | */
89 | private _setRateLimiter;
90 | limitTokens: any;
91 | limitIntervalMs: number;
92 | limiter: RateLimiter;
93 | /**
94 | * Runs the createEtchPacket mutation.
95 | * @param {Object} data
96 | * @param {Object} data.variables
97 | * @param {string} [data.responseQuery]
98 | * @param {string} [data.mutation]
99 | * @returns {Promise}
100 | */
101 | createEtchPacket({ variables, responseQuery, mutation }: {
102 | variables: any;
103 | responseQuery?: string;
104 | mutation?: string;
105 | }): Promise;
106 | /**
107 | * @param {string} documentGroupEid
108 | * @param {Object} [clientOptions]
109 | * @returns {Promise}
110 | */
111 | downloadDocuments(documentGroupEid: string, clientOptions?: any): Promise;
112 | /**
113 | * @param {string} pdfTemplateID
114 | * @param {Object} payload
115 | * @param {Object} [clientOptions]
116 | * @returns {Promise}
117 | */
118 | fillPDF(pdfTemplateID: string, payload: any, clientOptions?: any): Promise;
119 | /**
120 | * @param {Object} data
121 | * @param {Object} data.variables
122 | * @param {string} [data.responseQuery]
123 | * @param {string} [data.mutation]
124 | * @returns {Promise}
125 | */
126 | forgeSubmit({ variables, responseQuery, mutation }: {
127 | variables: any;
128 | responseQuery?: string;
129 | mutation?: string;
130 | }): Promise;
131 | /**
132 | * @param {Object} payload
133 | * @param {Object} [clientOptions]
134 | * @returns {Promise}
135 | */
136 | generatePDF(payload: any, clientOptions?: any): Promise;
137 | /**
138 | * @param {Object} data
139 | * @param {Object} data.variables
140 | * @param {string} [data.responseQuery]
141 | * @returns {Promise}
142 | */
143 | getEtchPacket({ variables, responseQuery }: {
144 | variables: any;
145 | responseQuery?: string;
146 | }): Promise;
147 | /**
148 | * @param {Object} data
149 | * @param {Object} data.variables
150 | * @returns {Promise<{url?: string, errors?: Array, statusCode: number}>}
151 | */
152 | generateEtchSignUrl({ variables }: {
153 | variables: any;
154 | }): Promise<{
155 | url?: string;
156 | errors?: Array;
157 | statusCode: number;
158 | }>;
159 | /**
160 | * @param {Object} data
161 | * @param {Object} data.variables
162 | * @param {string} [data.mutation]
163 | * @returns {Promise}
164 | */
165 | removeWeldData({ variables, mutation }: {
166 | variables: any;
167 | mutation?: string;
168 | }): Promise;
169 | /**
170 | * @param {Object} data
171 | * @param {string} data.query
172 | * @param {Object} [data.variables]
173 | * @param {Object} [clientOptions]
174 | * @returns {Promise}
175 | */
176 | requestGraphQL({ query, variables }: {
177 | query: string;
178 | variables?: any;
179 | }, clientOptions?: any): Promise;
180 | /**
181 | * @param {string} url
182 | * @param {Object} fetchOptions
183 | * @param {Object} [clientOptions]
184 | * @returns {Promise}
185 | */
186 | requestREST(url: string, fetchOptions: any, clientOptions?: any): Promise;
187 | _request(...args: any[]): any;
188 | /**
189 | * @param {string} url
190 | * @param {Object} options
191 | * @returns {Promise}
192 | * @private
193 | */
194 | private __request;
195 | /**
196 | * @param {CallableFunction} retryableRequestFn
197 | * @param {Object} [clientOptions]
198 | * @returns {Promise<*>}
199 | * @private
200 | */
201 | private _wrapRequest;
202 | /**
203 | * @param {string} path
204 | * @returns {string}
205 | * @private
206 | */
207 | private _url;
208 | /**
209 | * @param {Object} headerObject
210 | * @param {Object} headerObject.options
211 | * @param {Object} headerObject.headers
212 | * @param {Object} [internalOptions]
213 | * @returns {*&{headers: {}}}
214 | * @private
215 | */
216 | private _addHeaders;
217 | /**
218 | * @param {Object} options
219 | * @returns {*}
220 | * @private
221 | */
222 | private _addDefaultHeaders;
223 | /**
224 | * @param {CallableFunction} fn
225 | * @returns {Promise<*>}
226 | * @private
227 | */
228 | private _throttle;
229 | }
230 | declare namespace Anvil {
231 | export { UploadWithOptions };
232 | export { VERSION_LATEST };
233 | export { VERSION_LATEST_PUBLISHED };
234 | }
235 | import { Stream } from 'stream';
236 | import { RateLimiter } from 'limiter';
237 | import UploadWithOptions from './UploadWithOptions';
238 | declare const VERSION_LATEST: -1;
239 | declare const VERSION_LATEST_PUBLISHED: -2;
240 | //# sourceMappingURL=index.d.ts.map
--------------------------------------------------------------------------------
/types/src/index.d.ts.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.js"],"names":[],"mappings":";;aA0Bc,MAAM;kBACN,MAAM;cACN,MAAM;gBACN,MAAM;mBACN,MAAM;qBACN,MAAM;;;gBAMN,MAAM;WACN,mBAAmB;aACnB,MAAM,aAAa,GAAG,SAAS,CAAC;;;;;;;;gBAUhC,MAAM;WACN,MAAM,GAAC,MAAM,MAAO;aACpB,MAAM,aAAa,GAAG,SAAS,CAAC;;;;eAChC,GAAG;;wBAGH;IACZ,MAAM,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,GAAG,CAAC;CACb;;;aAGU,MAAM;aACN,MAAM;WACR,MAAM;aACJ,MAAM,kBAAkB,CAAC;;;;aAKzB,MAAM;eACJ,MAAM;;uBAIL;IACZ,IAAI,EAAE,MAAM,CAAA;CACb;AAyDD;IA+EE;;;;;;;;;;;;OAYG;IACH,iDATY,MAAM,GAAC,MAAM,GAAC,QAAQ,GAAC,IAAI,GAAC,IAAI,iEAMhC,iBAAiB,CA6C5B;IA/HD;;OAEG;IACH,qBAFW,YAAY,SA+BtB;IA1BC;;;;;;;MAKC;IAKD,mBAEoE;IAGpE,mCAAsC;IAEtC,kCAAqC;IAGrC,sCAEE;IADA,iDAAyC;IAO7C;;;;;OAKG;IACH,wBA8BC;IAHC,iBAAyB;IACzB,wBAAiC;IACjC,qBAAyB;IA4D3B;;;;;;;OAOG;IACH;QALwB,SAAS;QACR,aAAa,GAA3B,MAAM;QACQ,QAAQ,GAAtB,MAAM;QACJ,QAAQ,eAAe,CAAC,CAUpC;IAED;;;;OAIG;IACH,oCAJW,MAAM,wBAEJ,QAAQ,YAAY,CAAC,CAejC;IAED;;;;;OAKG;IACH,uBALW,MAAM,sCAGJ,QAAQ,YAAY,CAAC,CA2BjC;IAED;;;;;;OAMG;IACH;QALwB,SAAS;QACR,aAAa,GAA3B,MAAM;QACQ,QAAQ,GAAtB,MAAM;QACJ,QAAQ,eAAe,CAAC,CAUpC;IAED;;;;OAIG;IACH,gDAFa,QAAQ,YAAY,CAAC,CAsBjC;IAED;;;;;OAKG;IACH;QAJwB,SAAS;QACR,aAAa,GAA3B,MAAM;QACJ,QAAQ,eAAe,CAAC,CAUpC;IAED;;;;OAIG;IACH;QAHwB,SAAS;;cACL,MAAM;iBAAW,MAAM,aAAa,GAAG,SAAS,CAAC;oBAAc,MAAM;OAgBhG;IAED;;;;;OAKG;IACH;QAJwB,SAAS;QACR,QAAQ,GAAtB,MAAM;QACJ,QAAQ,eAAe,CAAC,CAUpC;IAED;;;;;;OAMG;IACH;QALwB,KAAK,EAAlB,MAAM;QACQ,SAAS;6BAErB,QAAQ,eAAe,CAAC,CAuIpC;IAED;;;;;OAKG;IACH,iBALW,MAAM,2CAGJ,QAAQ,YAAY,CAAC,CAmBjC;IAYD,8BAOC;IAED;;;;;OAKG;IACH,kBAMC;IAED;;;;;OAKG;IACH,qBAwFC;IAED;;;;OAIG;IACH,aAEC;IAED;;;;;;;OAOG;IACH,oBAqBC;IAED;;;;OAIG;IACH,2BAYC;IAED;;;;OAIG;IACH,kBA0BC;CACF;;;;;;uBAzzBsB,QAAQ;4BAGH,SAAS;8BAEP,qBAAqB;AAmHnD,iCAAyB;AAGzB,2CAAmC"}
--------------------------------------------------------------------------------
/types/src/validation.d.ts:
--------------------------------------------------------------------------------
1 | export function isFile(value: any): boolean;
2 | export function graphQLUploadSchemaIsValid(schema: any, parent: any, key: any): any;
3 | //# sourceMappingURL=validation.d.ts.map
--------------------------------------------------------------------------------
/types/src/validation.d.ts.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/validation.js"],"names":[],"mappings":"AAIA,4CAEC;AAED,oFAmCC"}
--------------------------------------------------------------------------------
102 |
103 | An example:
104 |
105 | ```js
106 | const fs = require('fs')
107 |
108 | // PDF template you uploaded to Anvil
109 | const pdfTemplateID = 'kA6Da9CuGqUtc6QiBDRR'
110 |
111 | // Your API key from your Anvil organization settings
112 | const apiKey = '7j2JuUWmN4fGjBxsCltWaybHOEy3UEtt'
113 |
114 | // JSON data to fill the PDF
115 | const payload = {
116 | "title": "My PDF Title",
117 | "fontSize": 10,
118 | "textColor": "#CC0000",
119 | "data": {
120 | "someFieldId": "Hello World!"
121 | }
122 | }
123 | // The 'options' parameter is optional
124 | const options = {
125 | "dataType": "buffer"
126 | }
127 | const anvilClient = new Anvil({ apiKey })
128 | const { statusCode, data } = await anvilClient.fillPDF(pdfTemplateID, payload, options)
129 |
130 | // Be sure to write the file as raw bytes
131 | fs.writeFileSync('filled.pdf', data, { encoding: null })
132 | ```
133 |
134 | * `pdfTemplateID` (String) - The id of your PDF template from the Anvil UI
135 | * `payload` (Object) - The JSON data that will fill the PDF template
136 | * `title` (String) - _optional_ Set the title encoded into the PDF document
137 | * `fontSize` (Number) - _optional_ Set the fontSize of all filled text. Default is 10.
138 | * `color` (String) - _optional_ Set the text color of all filled text. Default is dark blue.
139 | * `data` (Object) - The data to fill the PDF. The keys in this object will correspond to a field's ID in the PDF. These field IDs and their types are available on the `API Info` tab on your PDF template's page in the Anvil dashboard.
140 | * For example `{ "someFieldId": "Hello World!" }`
141 | * `options` (Object) - _optional_ Any additional options for the request
142 | * `dataType` (Enum[String]) - _optional_ Set the type of the `data` value that is returned in the resolved `Promise`. Defaults to `'buffer'`, but `'arrayBuffer'` and `'stream'` are also supported.
143 | * Returns a `Promise` that resolves to an `Object`
144 | * `statusCode` (Number) - the HTTP status code; `200` is success
145 | * `data` (Buffer | ArrayBuffer | Stream) - The raw binary data of the filled PDF if success. Will be either a Buffer, ArrayBuffer, or a Stream, depending on `dataType` option supplied to the request.
146 | * `errors` (Array of Objects) - Will be present if status >= 400. See Errors
147 | * `message` (String)
148 |
149 | ##### generatePDF(payload[, options])
150 |
151 | Dynamically generate a new PDF from your HTML and CSS or markdown.
152 |
153 | Useful for agreements, invoices, disclosures, or any other text-heavy documents. This does not require you do anything in the Anvil UI other than setup your API key, just send it data, get a PDF. See [the generate PDF docs](https://useanvil.com/api/generate-pdf) for full details.
154 |
155 | * [HTML to PDF docs](https://www.useanvil.com/docs/api/generate-pdf#html--css-to-pdf)
156 | * [Markdown to PDF docs](https://www.useanvil.com/docs/api/generate-pdf#markdown-to-pdf)
157 |
158 | Check out our [HTML invoice template](https://github.com/anvilco/html-pdf-invoice-template) for a complete HTML to PDF example.
159 |
160 | An example:
161 |
162 | ```js
163 | const fs = require('fs')
164 |
165 | // Your API key from your Anvil organization settings
166 | const apiKey = '7j2JuUWmN4fGjBxsCltWaybHOEy3UEtt'
167 |
168 | // An example using an HTML to PDF payload
169 | const payload = {
170 | title: 'Example',
171 | type: 'html',
172 | data: {
173 | html: `
174 |