├── .editorconfig
├── .env.example
├── .eslintrc.js
├── .github
    ├── CODEOWNERS
    ├── ISSUE_TEMPLATE.md
    ├── PULL_REQUEST_TEMPLATE.md
    ├── dependabot.yml
    └── workflows
    │   ├── pull-request.yml
    │   └── release.yml
├── .gitignore
├── .husky
    ├── .gitignore
    ├── commit-msg
    └── pre-commit
├── .prettierignore
├── .releaserc.json
├── CHANGELOG.md
├── CODE_OF_CONDUCT.md
├── LICENSE
├── README.md
├── babel.bundle.config.js
├── babel.config.js
├── bump.js
├── commitlint.config.js
├── cypress.config.ts
├── cypress
    ├── .eslintrc
    ├── e2e
    │   ├── api-error.cy.ts
    │   ├── applicationTemplates.cy.ts
    │   ├── applications.cy.ts
    │   ├── credit-card.cy.ts
    │   ├── elements.cy.ts
    │   ├── logs.cy.ts
    │   ├── permissions.cy.ts
    │   ├── proxies.cy.ts
    │   ├── reactor-formulas.cy.ts
    │   ├── reactors.cy.ts
    │   ├── tenants.cy.ts
    │   └── tokens.cy.ts
    ├── fixtures
    │   ├── credit_card_api_error.html
    │   ├── crud_client.html
    │   ├── elements.html
    │   └── event-informer.js
    ├── support
    │   ├── commands.ts
    │   ├── e2e.ts
    │   └── index.d.ts
    └── tsconfig.json
├── examples
    └── credit_card.html
├── jest.config.js
├── makefile
├── package.json
├── prepare.js
├── scripts
    ├── acceptance.sh
    ├── build.sh
    ├── setupinfra.sh
    ├── verify.sh
    └── writelibvars.sh
├── src
    ├── BasisTheory.ts
    ├── application-templates
    │   ├── BasisTheoryApplicationTemplates.ts
    │   └── index.ts
    ├── applicationKeys
    │   ├── BasisTheoryApplicationKeys.ts
    │   └── index.ts
    ├── applications
    │   ├── BasisTheoryApplications.ts
    │   └── index.ts
    ├── common
    │   ├── BasisTheoryApiError.ts
    │   ├── BasisTheoryValidationError.ts
    │   ├── HttpClientError.ts
    │   ├── constants.ts
    │   ├── index.ts
    │   ├── logging.ts
    │   └── utils.ts
    ├── elements
    │   ├── constants.ts
    │   ├── index.ts
    │   ├── load.ts
    │   ├── script.ts
    │   └── services
    │   │   ├── index.ts
    │   │   ├── proxy.ts
    │   │   ├── token-intents.ts
    │   │   ├── tokenize.ts
    │   │   └── tokens.ts
    ├── index.ts
    ├── logs
    │   ├── BasisTheoryLogs.ts
    │   └── index.ts
    ├── permissions
    │   ├── BasisTheoryPermissions.ts
    │   └── index.ts
    ├── proxies
    │   ├── BasisTheoryProxies.ts
    │   └── index.ts
    ├── proxy
    │   ├── BasisTheoryProxy.ts
    │   └── index.ts
    ├── reactor-formulas
    │   ├── BasisTheoryReactorFormulas.ts
    │   └── index.ts
    ├── reactors
    │   ├── BasisTheoryReactors.ts
    │   └── index.ts
    ├── service
    │   ├── BasisTheoryService.ts
    │   ├── CrudBuilder.ts
    │   ├── index.ts
    │   └── types.ts
    ├── sessions
    │   ├── BasisTheorySessions.ts
    │   └── index.ts
    ├── tenants
    │   ├── BasisTheoryTenants.ts
    │   └── index.ts
    ├── threeds
    │   ├── BasisTheoryThreeDs.ts
    │   └── index.ts
    ├── token-intents
    │   ├── BasisTheoryTokenIntents.ts
    │   └── index.ts
    ├── tokenize
    │   ├── BasisTheoryTokenize.ts
    │   └── index.ts
    ├── tokens
    │   ├── BasisTheoryTokens.ts
    │   └── index.ts
    └── types
    │   ├── elements
    │       ├── cardTypes.ts
    │       ├── elements.ts
    │       ├── events.ts
    │       ├── index.ts
    │       ├── options.ts
    │       ├── services
    │       │   ├── index.ts
    │       │   ├── proxy.ts
    │       │   ├── token-intents.ts
    │       │   ├── tokenize.ts
    │       │   └── tokens.ts
    │       ├── shared.ts
    │       └── styles.ts
    │   ├── models
    │       ├── application-templates.ts
    │       ├── applications.ts
    │       ├── banks.ts
    │       ├── bin-details.ts
    │       ├── card-details.ts
    │       ├── cards.ts
    │       ├── index.ts
    │       ├── logs.ts
    │       ├── permissions.ts
    │       ├── proxies.ts
    │       ├── reactor-formulas.ts
    │       ├── reactors.ts
    │       ├── shared.ts
    │       ├── tenants.ts
    │       ├── threeds.ts
    │       ├── token-intents.ts
    │       ├── tokenize.ts
    │       ├── tokens.ts
    │       └── util.ts
    │   └── sdk
    │       ├── index.ts
    │       ├── sdk.ts
    │       └── services
    │           ├── application-templates.ts
    │           ├── applicationKeys.ts
    │           ├── applications.ts
    │           ├── http.ts
    │           ├── index.ts
    │           ├── logs.ts
    │           ├── permissions.ts
    │           ├── proxies.ts
    │           ├── proxy.ts
    │           ├── reactor-formulas.ts
    │           ├── reactors.ts
    │           ├── sessions.ts
    │           ├── shared.ts
    │           ├── tenants.ts
    │           ├── threeds.ts
    │           ├── token-intents.ts
    │           ├── tokenize.ts
    │           └── tokens.ts
├── test
    ├── application-templates.test.ts
    ├── applicationKeys.test.ts
    ├── applications.test.ts
    ├── clients.test.ts
    ├── elements.test.ts
    ├── elements
    │   ├── create.test.ts
    │   ├── httpClient.test.ts
    │   ├── proxy.test.ts
    │   ├── tokenIntents.test.ts
    │   ├── tokenize.test.ts
    │   └── tokens.test.ts
    ├── init.test.ts
    ├── logs.test.ts
    ├── permissions.test.ts
    ├── proxies.test.ts
    ├── proxy.test.ts
    ├── reactor-formulas.test.ts
    ├── reactors.test.ts
    ├── script.test.ts
    ├── sessions.test.ts
    ├── setup
    │   └── utils.ts
    ├── tenants.test.ts
    ├── threeds.test.ts
    ├── token-intents.test.ts
    ├── tokenize.test.ts
    ├── tokens.test.ts
    ├── tsconfig.json
    └── utils.test.ts
├── tsconfig.json
├── webpack.common.js
├── webpack.dev.js
├── webpack.prod.js
└── yarn.lock


/.editorconfig:
--------------------------------------------------------------------------------
 1 | root = true
 2 | 
 3 | [*]
 4 | indent_style = space
 5 | indent_size = 2
 6 | charset = utf-8
 7 | trim_trailing_whitespace = true
 8 | insert_final_newline = true
 9 | end_of_line = lf
10 | # editorconfig-tools is unable to ignore longs strings or urls
11 | max_line_length = off
12 | 


--------------------------------------------------------------------------------
/.env.example:
--------------------------------------------------------------------------------
1 | JS_HOST=js-dev.basistheory.com
2 | API_HOST=localhost:3333
3 | ELEMENTS_HOST=localhost:3000
4 | 


--------------------------------------------------------------------------------
/.eslintrc.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 |   root: true,
 3 |   extends: '@basis-theory/eslint-config/typescript',
 4 |   rules: {
 5 |     'unicorn/no-null': 'warn',
 6 |     camelcase: [
 7 |       'error',
 8 |       {
 9 |         allow: [
10 |           'expiration_month',
11 |           'expiration_year',
12 |           'snake_case',
13 |           'total_items',
14 |           'page_number',
15 |           'page_size',
16 |           'total_pages',
17 |           'created_at',
18 |           'modified_at',
19 |           'created_by',
20 |           'modified_by',
21 |           'first_nested',
22 |           'second_nested',
23 |           'tenant_id',
24 |           'session_key',
25 |           'expires_at',
26 |           'owner_id',
27 |           'token_report',
28 |           'metrics_by_type',
29 |           'monthly_active_tokens',
30 |           'included_monthly_active_tokens',
31 |           'application_type',
32 |           'template_type',
33 |         ],
34 |       },
35 |     ],
36 |   },
37 | };
38 | 


--------------------------------------------------------------------------------
/.github/CODEOWNERS:
--------------------------------------------------------------------------------
1 | # This is a comment.
2 | # Each line is a file pattern followed by one or more owners.
3 | 
4 | # These owners will be the default owners for everything in
5 | # the repo.
6 | *	@basis-theory/engineers
7 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE.md:
--------------------------------------------------------------------------------
 1 | For additional support or to discuss issues/features, please reach out to us on our [Community](https://community.basistheory.com) or via email at [support@basistheory.com](mailto:support@basistheory.com)
 2 | 
 3 | ## Expected Behavior
 4 | -
 5 | 
 6 | ## Actual Behavior
 7 | -
 8 | 
 9 | ## Steps to Reproduce the Problem
10 | 1.
11 | 1.
12 | 1.
13 | 
14 | ## Specifications
15 | - SDK Version:
16 | - NodeJS version:
17 | 


--------------------------------------------------------------------------------
/.github/PULL_REQUEST_TEMPLATE.md:
--------------------------------------------------------------------------------
 1 | <!-- Describe your changes in detail -->
 2 | ## Description
 3 | 
 4 | -
 5 | 
 6 | <!-- Please describe in detail how teammates can test your changes. -->
 7 | ## Testing required outside of automated testing?
 8 | 
 9 | - [ ] Not Applicable
10 | 
11 | <!-- Provide Screenshots when applicable -->
12 | ### Screenshots (if appropriate):
13 | 
14 | - [ ] Not Applicable
15 | 
16 | <!-- Describe Rollback or Rollforward Procedure -->
17 | ## Rollback / Rollforward Procedure
18 | 
19 | - [ ] Roll Forward
20 | - [ ] Roll Back
21 | 
22 | ## Reviewer Checklist
23 | 
24 | - [ ] Description of Change
25 | - [ ] Description of outside testing if applicable.
26 | - [ ] Description of Roll Forward / Backward Procedure
27 | - [ ] Documentation updated for Change
28 | 


--------------------------------------------------------------------------------
/.github/dependabot.yml:
--------------------------------------------------------------------------------
1 | version: 2
2 | updates:
3 |   - package-ecosystem: "npm"
4 |     directory: "/"
5 |     schedule:
6 |       interval: "weekly"
7 | 


--------------------------------------------------------------------------------
/.github/workflows/pull-request.yml:
--------------------------------------------------------------------------------
  1 | name: Pull Request
  2 | 
  3 | on:
  4 |   pull_request:
  5 |     branches: [master]
  6 | 
  7 | concurrency:
  8 |   group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
  9 |   cancel-in-progress: true
 10 | 
 11 | jobs:
 12 |   build:
 13 |     environment: DEV
 14 |     runs-on: ${{ matrix.os }}
 15 |     strategy:
 16 |       matrix:
 17 |         node: ["14.x"]
 18 |         os: [ubuntu-latest]
 19 |     env:
 20 |       CI: 1 # prevents extra Cypress installation progress messages
 21 |       HUSKY: 0 # disables husky hooks
 22 |     steps:
 23 |       - name: Checkout repo
 24 |         uses: actions/checkout@v2
 25 | 
 26 |       - name: Use Node ${{ matrix.node }}
 27 |         uses: actions/setup-node@v1
 28 |         with:
 29 |           node-version: ${{ matrix.node }}
 30 | 
 31 |       - name: Install deps (with cache)
 32 |         uses: bahmutov/npm-install@v1
 33 |         env:
 34 |           CYPRESS_INSTALL_BINARY: 0
 35 | 
 36 |       - id: read-package-json
 37 |         name: Read package.json
 38 |         run: |
 39 |           content=`cat package.json`
 40 |           content="${content//'%'/'%25'}"
 41 |           content="${content//$'\n'/'%0A'}"
 42 |           content="${content//$'\r'/'%0D'}"
 43 |           echo "::set-output name=packageJson::$content"
 44 | 
 45 |       - name: Cache Cypress Binaries
 46 |         id: cache-cypress
 47 |         uses: actions/cache@v4
 48 |         with:
 49 |           path: ~/.cache/Cypress
 50 |           key: cypress-cache-v4-${{ runner.os }}-${{ fromJson(steps.read-package-json.outputs.packageJson).devDependencies.cypress }}
 51 | 
 52 |       # Install and check Cypress binary
 53 |       - run: yarn run cypress install
 54 |       - run: yarn run cypress cache list
 55 | 
 56 |       - name: Write .env
 57 |         run: make write-lib-vars
 58 |         env:
 59 |           ENVIRONMENT: dev
 60 |           DD_GIT_SHA: ${{ github.sha }}
 61 |           IS_PR_WORKFLOW: true
 62 | 
 63 |       - name: Verify
 64 |         run: make verify
 65 |         env:
 66 |           SKIP_INSTALL: 1 # install with cache was done already
 67 | 
 68 |       - name: Upload failed e2e tests screenshots
 69 |         uses: actions/upload-artifact@v4
 70 |         if: failure()
 71 |         with:
 72 |           name: cypress-screenshots
 73 |           path: cypress/screenshots
 74 | 
 75 |       - name: Verify Infrastructure
 76 |         run: make setup-infra
 77 |         env:
 78 |           AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
 79 |           AWS_REGION: us-east-2
 80 |           AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY_ID }}
 81 |           ENVIRONMENT: dev
 82 |           IS_PR_WORKFLOW: true
 83 | 
 84 |       - name: Purge cache
 85 |         uses: jakejarvis/cloudflare-purge-action@master
 86 |         env:
 87 |           CLOUDFLARE_ZONE: ${{ vars.CF_DEV_ZONE_ID }}
 88 |           CLOUDFLARE_TOKEN: ${{ secrets.CLOUDFLARE_PURGE_TOKEN }}
 89 |           PURGE_URLS: '["https://js.flock-dev.com/*"]'
 90 | 
 91 |       - name: Monitor coverage
 92 |         uses: slavcodev/coverage-monitor-action@1.2.0
 93 |         with:
 94 |           github_token: ${{ secrets.GITHUB_TOKEN }}
 95 |           clover_file: "coverage/clover.xml"
 96 |           threshold_alert: 80
 97 |           threshold_warning: 90
 98 | 
 99 |   pr-security-check:
100 |     name: PR Security Check
101 |     uses: Basis-Theory/public-security-workflows/.github/workflows/pr-check.yml@master
102 |     secrets: inherit
103 | 


--------------------------------------------------------------------------------
/.github/workflows/release.yml:
--------------------------------------------------------------------------------
 1 | name: Release
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: [master]
 6 | 
 7 | jobs:
 8 |   build-release:
 9 |     environment: PROD
10 |     runs-on: ${{ matrix.os }}
11 |     strategy:
12 |       matrix:
13 |         node: ["14.x"]
14 |         os: [ubuntu-latest]
15 |     env:
16 |       CI: 1 # prevents extra Cypress installation progress messages
17 |       HUSKY: 0 # disables husky hooks
18 |     steps:
19 |       - name: Checkout repo
20 |         uses: actions/checkout@v2
21 |         with:
22 |           token: ${{ secrets.GH_SEMANTIC_RELEASE_PAT }}
23 | 
24 |       - name: Start Deploy Message
25 |         uses: Basis-Theory/github-actions/deploy-slack-action@master
26 |         with:
27 |           slack-api-token: ${{ secrets.SLACK_DUCKBOT_API_KEY }}
28 |           channel: ${{ vars.SLACK_DUCKBOT_RELEASE_CHANNEL_ID }}
29 | 
30 |       - name: Use Node ${{ matrix.node }}
31 |         uses: actions/setup-node@v1
32 |         with:
33 |           node-version: ${{ matrix.node }}
34 | 
35 |       - name: Install deps (with cache)
36 |         uses: bahmutov/npm-install@v1
37 |         env:
38 |           CYPRESS_INSTALL_BINARY: 0
39 | 
40 |       - name: Write .env
41 |         run: make write-lib-vars
42 |         env:
43 |           ENVIRONMENT: prod
44 |           DD_GIT_SHA: ${{ github.sha }}
45 | 
46 |       - name: Build
47 |         run: make build
48 |         env:
49 |           SKIP_INSTALL: 1 # install with cache was done already
50 | 
51 |       - name: Release
52 |         run: make release
53 |         env:
54 |           AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
55 |           AWS_REGION: us-east-2
56 |           AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY_ID }}
57 |           ENVIRONMENT: prod
58 |           GITHUB_TOKEN: ${{ secrets.GH_SEMANTIC_RELEASE_PAT }}
59 |           NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
60 | 
61 |       - name: Purge cache
62 |         uses: jakejarvis/cloudflare-purge-action@master
63 |         env:
64 |           CLOUDFLARE_ZONE: ${{ vars.CF_PROD_ZONE_ID }}
65 |           CLOUDFLARE_TOKEN: ${{ secrets.CLOUDFLARE_PURGE_TOKEN }}
66 |           PURGE_URLS: '["https://js.basistheory.com/*"]'
67 | 
68 |       - name: Stop Deploy Message
69 |         if: always()
70 |         uses: Basis-Theory/github-actions/deploy-slack-action@master
71 |         with:
72 |           slack-api-token: ${{ secrets.SLACK_DUCKBOT_API_KEY }}
73 |           channel: ${{ vars.SLACK_DUCKBOT_RELEASE_CHANNEL_ID }}
74 |           status: "done"
75 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | *.log
 2 | .DS_Store
 3 | node_modules
 4 | dist
 5 | coverage
 6 | cypress/screenshots
 7 | cypress/downloads
 8 | .nvmrc
 9 | .npmrc
10 | .idea
11 | .env
12 | .vscode/
13 | 


--------------------------------------------------------------------------------
/.husky/.gitignore:
--------------------------------------------------------------------------------
1 | _
2 | 


--------------------------------------------------------------------------------
/.husky/commit-msg:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | . "$(dirname "$0")/_/husky.sh"
3 | 
4 | yarn commitlint --edit 
5 | 


--------------------------------------------------------------------------------
/.husky/pre-commit:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | . "$(dirname "$0")/_/husky.sh"
3 | 
4 | yarn pretty-quick


--------------------------------------------------------------------------------
/.prettierignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | dist
3 | coverage
4 | .github
5 | CHANGELOG.md


--------------------------------------------------------------------------------
/.releaserc.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "branches": ["master"],
 3 |   "plugins": [
 4 |     [
 5 |       "@semantic-release/commit-analyzer",
 6 |       {
 7 |         "releaseRules": [{ "type": "refactor", "release": "patch" }]
 8 |       }
 9 |     ],
10 |     "@semantic-release/release-notes-generator",
11 |     "@semantic-release/changelog",
12 |     [
13 |       "@semantic-release/npm",
14 |       {
15 |         "pkgRoot": "dist"
16 |       }
17 |     ],
18 |     "@semantic-release/github",
19 |     [
20 |       "@semantic-release/git",
21 |       {
22 |         "assets": ["package.json", "CHANGELOG.md"],
23 |         "message": "chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
24 |       }
25 |     ],
26 |     [
27 |       "@semantic-release/exec",
28 |       {
29 |         "verifyReleaseCmd": "echo VERSION=${nextRelease.version} >> .env"
30 |       }
31 |     ]
32 |   ]
33 | }
34 | 


--------------------------------------------------------------------------------
/CODE_OF_CONDUCT.md:
--------------------------------------------------------------------------------
  1 | # Contributor Covenant Code of Conduct
  2 | 
  3 | ## Our Pledge
  4 | 
  5 | We as members, contributors, and leaders pledge to make participation in our
  6 | community a harassment-free experience for everyone, regardless of age, body
  7 | size, visible or invisible disability, ethnicity, sex characteristics, gender
  8 | identity and expression, level of experience, education, socio-economic status,
  9 | nationality, personal appearance, race, caste, color, religion, or sexual identity
 10 | and orientation.
 11 | 
 12 | We pledge to act and interact in ways that contribute to an open, welcoming,
 13 | diverse, inclusive, and healthy community.
 14 | 
 15 | ## Our Standards
 16 | 
 17 | Examples of behavior that contributes to a positive environment for our
 18 | community include:
 19 | 
 20 | - Demonstrating empathy and kindness toward other people
 21 | - Being respectful of differing opinions, viewpoints, and experiences
 22 | - Giving and gracefully accepting constructive feedback
 23 | - Accepting responsibility and apologizing to those affected by our mistakes,
 24 |   and learning from the experience
 25 | - Focusing on what is best not just for us as individuals, but for the
 26 |   overall community
 27 | 
 28 | Examples of unacceptable behavior include:
 29 | 
 30 | - The use of sexualized language or imagery, and sexual attention or
 31 |   advances of any kind
 32 | - Trolling, insulting or derogatory comments, and personal or political attacks
 33 | - Public or private harassment
 34 | - Publishing others' private information, such as a physical or email
 35 |   address, without their explicit permission
 36 | - Other conduct which could reasonably be considered inappropriate in a
 37 |   professional setting
 38 | 
 39 | ## Enforcement Responsibilities
 40 | 
 41 | Community leaders are responsible for clarifying and enforcing our standards of
 42 | acceptable behavior and will take appropriate and fair corrective action in
 43 | response to any behavior that they deem inappropriate, threatening, offensive,
 44 | or harmful.
 45 | 
 46 | Community leaders have the right and responsibility to remove, edit, or reject
 47 | comments, commits, code, wiki edits, issues, and other contributions that are
 48 | not aligned to this Code of Conduct, and will communicate reasons for moderation
 49 | decisions when appropriate.
 50 | 
 51 | ## Scope
 52 | 
 53 | This Code of Conduct applies within all community spaces, and also applies when
 54 | an individual is officially representing the community in public spaces.
 55 | Examples of representing our community include using an official e-mail address,
 56 | posting via an official social media account, or acting as an appointed
 57 | representative at an online or offline event.
 58 | 
 59 | ## Enforcement
 60 | 
 61 | Instances of abusive, harassing, or otherwise unacceptable behavior may be
 62 | reported to the community leaders responsible for enforcement at
 63 | [support@basistheory.com](mailto:support@basistheory.com?subject=Conduct).
 64 | All complaints will be reviewed and investigated promptly and fairly.
 65 | 
 66 | All community leaders are obligated to respect the privacy and security of the
 67 | reporter of any incident.
 68 | 
 69 | ## Enforcement Guidelines
 70 | 
 71 | Community leaders will follow these Community Impact Guidelines in determining
 72 | the consequences for any action they deem in violation of this Code of Conduct:
 73 | 
 74 | ### 1. Correction
 75 | 
 76 | **Community Impact**: Use of inappropriate language or other behavior deemed
 77 | unprofessional or unwelcome in the community.
 78 | 
 79 | **Consequence**: A private, written warning from community leaders, providing
 80 | clarity around the nature of the violation and an explanation of why the
 81 | behavior was inappropriate. A public apology may be requested.
 82 | 
 83 | ### 2. Warning
 84 | 
 85 | **Community Impact**: A violation through a single incident or series
 86 | of actions.
 87 | 
 88 | **Consequence**: A warning with consequences for continued behavior. No
 89 | interaction with the people involved, including unsolicited interaction with
 90 | those enforcing the Code of Conduct, for a specified period of time. This
 91 | includes avoiding interactions in community spaces as well as external channels
 92 | like social media. Violating these terms may lead to a temporary or
 93 | permanent ban.
 94 | 
 95 | ### 3. Temporary Ban
 96 | 
 97 | **Community Impact**: A serious violation of community standards, including
 98 | sustained inappropriate behavior.
 99 | 
100 | **Consequence**: A temporary ban from any sort of interaction or public
101 | communication with the community for a specified period of time. No public or
102 | private interaction with the people involved, including unsolicited interaction
103 | with those enforcing the Code of Conduct, is allowed during this period.
104 | Violating these terms may lead to a permanent ban.
105 | 
106 | ### 4. Permanent Ban
107 | 
108 | **Community Impact**: Demonstrating a pattern of violation of community
109 | standards, including sustained inappropriate behavior, harassment of an
110 | individual, or aggression toward or disparagement of classes of individuals.
111 | 
112 | **Consequence**: A permanent ban from any sort of public interaction within
113 | the community.
114 | 
115 | ## Attribution
116 | 
117 | This Code of Conduct is adapted from the [Contributor Covenant][homepage],
118 | version 2.1, available at
119 | [https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
120 | 
121 | Community Impact Guidelines were inspired by
122 | [Mozilla's code of conduct enforcement ladder][mozilla coc].
123 | 
124 | For answers to common questions about this code of conduct, see the FAQ at
125 | [https://www.contributor-covenant.org/faq][faq]. Translations are available
126 | at [https://www.contributor-covenant.org/translations][translations].
127 | 
128 | [homepage]: https://www.contributor-covenant.org
129 | [v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
130 | [mozilla coc]: https://github.com/mozilla/diversity
131 | [faq]: https://www.contributor-covenant.org/faq
132 | [translations]: https://www.contributor-covenant.org/translations
133 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Basis Theory JS SDK (aka BasisTheory.js)
  2 | 
  3 | > [!CAUTION]
  4 | > This SDK has been deprecated for use in Node.js environments. It is still supported for use in web elements and reactor environments.
  5 | >
  6 | > Our new Node.js SDK can be found at https://github.com/Basis-Theory/node-sdk
  7 | >
  8 | > See our documentation site for more information. https://developers.basistheory.com/docs/sdks/server-side/node
  9 | 
 10 | [![Version](https://img.shields.io/npm/v/@basis-theory/basis-theory-js.svg)](https://www.npmjs.org/package/@basis-theory/basis-theory-js)
 11 | [![Downloads](https://img.shields.io/npm/dm/@basis-theory/basis-theory-js.svg)](https://www.npmjs.org/package/@basis-theory/basis-theory-js)
 12 | [![Verify](https://github.com/Basis-Theory/basis-theory-js/actions/workflows/release.yml/badge.svg)](https://github.com/Basis-Theory/basis-theory-js/actions/workflows/release.yml)
 13 | 
 14 | The [Basis Theory](https://basistheory.com/) JS SDK
 15 | 
 16 | ## Installation
 17 | 
 18 | Using [Node Package Manager](https://docs.npmjs.com/)
 19 | 
 20 | ```sh
 21 | npm install --save @basis-theory/basis-theory-js
 22 | ```
 23 | 
 24 | Using [Yarn](https://classic.yarnpkg.com/en/docs/)
 25 | 
 26 | ```sh
 27 | yarn add @basis-theory/basis-theory-js
 28 | ```
 29 | 
 30 | ## Documentation
 31 | 
 32 | For a complete list of endpoints and examples, please refer to our [API docs](https://docs.basistheory.com/api-reference/?javascript#introduction)
 33 | 
 34 | ## Usage
 35 | 
 36 | ### Initialization
 37 | 
 38 | ```javascript
 39 | import { BasisTheory } from '@basis-theory/basis-theory-js';
 40 | 
 41 | const bt = await new BasisTheory().init('<API Key>'); // replace with your application key
 42 | ```
 43 | 
 44 | ### Per-request configuration
 45 | 
 46 | All of the service methods accept an optional `RequestOptions` object. This is used if you want to set a per-request `BT-TRACE-ID`, `BT-API-KEY` and/or `BT-IDEMPOTENCY-KEY`.
 47 | 
 48 | ```javascript
 49 | import { v4 as uuid } from 'uuid';
 50 | 
 51 | await bt.applications.list(
 52 |   {},
 53 |   {
 54 |     apiKey: '<Management API Key>',
 55 |     correlationId: 'aa5d3379-6385-4ef4-9fdb-ca1341572153',
 56 |     idempotencyKey: 'bb5d3379-6385-4ef4-9fdb-ca1341572154',
 57 |   }
 58 | );
 59 | 
 60 | await bt.tokens.create(
 61 |   {
 62 |     type: "token",
 63 |     data: "Sensitive Value",
 64 |   },
 65 |   {
 66 |     apiKey: '<API Key>',
 67 |     correlationId: 'aa5d3379-6385-4ef4-9fdb-ca1341572153',
 68 |     idempotencyKey: 'bb5d3379-6385-4ef4-9fdb-ca1341572154',
 69 |   }
 70 | );
 71 | ```
 72 | 
 73 | ### Setting a custom API Url
 74 | 
 75 | You can set a custom API Url to be used across all clients when creating a new SDK instance.
 76 | 
 77 | ```javascript
 78 | import { BasisTheory } from '@basis-theory/basis-theory-js';
 79 | 
 80 | const bt = await new BasisTheory().init('<API Key>', {
 81 |   apiBaseUrl: 'https://api.somedomain.com',
 82 | }); // replace with your application key and api base URL.
 83 | ```
 84 | 
 85 | ### Elements
 86 | 
 87 | Please, refer to the [Elements Documentation](https://docs.basistheory.com/elements) on how to use it.
 88 | 
 89 | ## Development
 90 | 
 91 | The provided scripts with the SDK will check for all dependencies, start docker, build the solution, and run all tests.
 92 | 
 93 | ### Dependencies
 94 | 
 95 | - [Docker](https://www.docker.com/products/docker-desktop)
 96 | - [Docker Compose](https://www.docker.com/products/docker-desktop)
 97 | - [NodeJS](https://nodejs.org/en/) > 10.12.0
 98 | - [Yarn](https://classic.yarnpkg.com/en/docs/)
 99 | 
100 | ### Build the SDK and run Tests
101 | 
102 | Run the following command from the root of the project:
103 | 
104 | ```sh
105 | make verify
106 | ```
107 | 


--------------------------------------------------------------------------------
/babel.bundle.config.js:
--------------------------------------------------------------------------------
 1 | // this Babel configuration is used in webpack library bundle
 2 | module.exports = {
 3 |   presets: [
 4 |     [
 5 |       '@babel/preset-env',
 6 |       {
 7 |         targets: '>0.25%',
 8 |       },
 9 |     ],
10 |     '@babel/typescript',
11 |   ],
12 |   plugins: [
13 |     '@babel/proposal-class-properties',
14 |     '@babel/plugin-transform-runtime',
15 |     [
16 |       'babel-plugin-transform-builtin-extend',
17 |       {
18 |         globals: ['Error'],
19 |       },
20 |     ],
21 |   ],
22 | };
23 | 


--------------------------------------------------------------------------------
/babel.config.js:
--------------------------------------------------------------------------------
 1 | // this file is used to transpile Typescript files into Javascript files (dist/*)
 2 | // for ES module usage
 3 | module.exports = {
 4 |   presets: [
 5 |     [
 6 |       '@babel/preset-env',
 7 |       {
 8 |         targets: {
 9 |           node: '10',
10 |         },
11 |       },
12 |     ],
13 |     '@babel/typescript',
14 |   ],
15 |   plugins: [
16 |     'tsconfig-paths-module-resolver',
17 |     '@babel/proposal-class-properties',
18 |     ['inline-dotenv', { unsafe: true }],
19 |     [
20 |       'babel-plugin-transform-builtin-extend',
21 |       {
22 |         globals: ['Error'],
23 |       },
24 |     ],
25 |   ],
26 | };
27 | 


--------------------------------------------------------------------------------
/bump.js:
--------------------------------------------------------------------------------
 1 | // copies the version from dist/package.json to package.json, after @semantic-release/npm bumps it
 2 | const fs = require('fs');
 3 | const distPackage = require('./dist/package.json');
 4 | const libPackage = require('./package.json');
 5 | 
 6 | libPackage.version = distPackage.version;
 7 | 
 8 | fs.writeFileSync(
 9 |   './package.json',
10 |   `${JSON.stringify(libPackage, undefined, 2)}\n`
11 | );
12 | 
13 | // removes dist package scripts before publish
14 | delete distPackage.scripts;
15 | fs.writeFileSync(
16 |   './dist/package.json',
17 |   JSON.stringify(distPackage, undefined, 2)
18 | );
19 | 


--------------------------------------------------------------------------------
/commitlint.config.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 |   extends: ['@commitlint/config-conventional'],
3 |   rules: {
4 |     'body-max-line-length': [0],
5 |   },
6 | };
7 | 


--------------------------------------------------------------------------------
/cypress.config.ts:
--------------------------------------------------------------------------------
1 | import { defineConfig } from 'cypress';
2 | 
3 | export default defineConfig({
4 |   screenshotsFolder: 'cypress/screenshots',
5 |   video: false,
6 |   fixturesFolder: false,
7 |   e2e: {},
8 | });
9 | 


--------------------------------------------------------------------------------
/cypress/.eslintrc:
--------------------------------------------------------------------------------
1 | {
2 |   "rules": {
3 |     "@typescript-eslint/triple-slash-reference": "off"
4 |   }
5 | }
6 | 


--------------------------------------------------------------------------------
/cypress/e2e/api-error.cy.ts:
--------------------------------------------------------------------------------
 1 | // eslint-disable-next-line spaced-comment
 2 | ///  <reference path="../support/index.d.ts" />
 3 | 
 4 | context('API error', () => {
 5 |   beforeEach(() => {
 6 |     cy.visit('./cypress/fixtures/credit_card_api_error.html');
 7 |   });
 8 | 
 9 |   context('network error/network offline', () => {
10 |     // eslint-disable-next-line jest/no-duplicate-hooks
11 |     beforeEach(() => {
12 |       cy.intercept('POST', '/tokens', {
13 |         forceNetworkError: true,
14 |       });
15 |     });
16 | 
17 |     it('should return error with status of -1 and data of undefined', () => {
18 |       cy.get('form').find('#card_number').type('4242424242424242');
19 |       cy.get('form').find('#expiration_month').type('10');
20 |       cy.get('form').find('#expiration_year').type('2029');
21 |       cy.get('form').find('#cvc').type('123');
22 |       cy.get('form').submit();
23 |       cy.get('#response').should(
24 |         'have.text',
25 |         JSON.stringify({
26 |           status: -1,
27 |           name: 'BasisTheoryApiError',
28 |         })
29 |       );
30 |     });
31 |   });
32 | 
33 |   context('error response', () => {
34 |     const status = 400,
35 |       message = 'some error response';
36 | 
37 |     // eslint-disable-next-line jest/no-duplicate-hooks
38 |     beforeEach(() => {
39 |       cy.intercept('POST', '/tokens', {
40 |         statusCode: status,
41 |         body: { message },
42 |       });
43 |     });
44 | 
45 |     it('should return error with the API status and data', () => {
46 |       cy.get('form').find('#card_number').type('4242424242424242');
47 |       cy.get('form').find('#expiration_month').type('10');
48 |       cy.get('form').find('#expiration_year').type('2029');
49 |       cy.get('form').find('#cvc').type('123');
50 |       cy.get('form').submit();
51 |       cy.get('#response').should(
52 |         'have.text',
53 |         JSON.stringify({
54 |           status,
55 |           data: {
56 |             message,
57 |           },
58 |           name: 'BasisTheoryApiError',
59 |         })
60 |       );
61 |     });
62 |   });
63 | });
64 | 


--------------------------------------------------------------------------------
/cypress/e2e/applicationTemplates.cy.ts:
--------------------------------------------------------------------------------
 1 | // eslint-disable-next-line spaced-comment
 2 | ///  <reference path="../support/index.d.ts" />
 3 | 
 4 | context('Application Templates', () => {
 5 |   it('should retrieve', () => {
 6 |     cy.testRetrieve('application-templates');
 7 |   });
 8 |   it('should list', () => {
 9 |     cy.testList('application-templates');
10 |   });
11 | });
12 | 


--------------------------------------------------------------------------------
/cypress/e2e/applications.cy.ts:
--------------------------------------------------------------------------------
 1 | // eslint-disable-next-line spaced-comment
 2 | ///  <reference path="../support/index.d.ts" />
 3 | 
 4 | context('Applications', () => {
 5 |   it('should create', () => {
 6 |     cy.testCreate('applications');
 7 |   });
 8 |   it('should retrieve', () => {
 9 |     cy.testRetrieve('applications');
10 |   });
11 |   it('should update', () => {
12 |     cy.testUpdate('applications');
13 |   });
14 |   it('should delete', () => {
15 |     cy.testDelete('applications');
16 |   });
17 |   it('should list', () => {
18 |     cy.testList('applications');
19 |   });
20 | });
21 | 


--------------------------------------------------------------------------------
/cypress/e2e/credit-card.cy.ts:
--------------------------------------------------------------------------------
 1 | import { v4 as uuid } from 'uuid';
 2 | 
 3 | context('Credit Card example', () => {
 4 |   const port = Cypress.config('port');
 5 | 
 6 |   beforeEach(() => {
 7 |     cy.intercept('https://js.basistheory.com/', (req) => {
 8 |       req.redirect(`http://localhost:${port}/dist/basis-theory-js.bundle.js`);
 9 |     });
10 | 
11 |     cy.visit('examples/credit_card.html');
12 | 
13 |     cy.intercept(
14 |       {
15 |         pathname: '/tokens',
16 |       },
17 |       (req) => {
18 |         req.reply({
19 |           statusCode: 201,
20 |           body: {
21 |             id: uuid(),
22 |             data: {
23 |               number: `${'X'.repeat(
24 |                 req.body.data.number.length - 4
25 |               )}${req.body.data.number.slice(-4)}`,
26 |               expiration_month: req.body.data.expiration_month,
27 |               expiration_year: req.body.data.expiration_year,
28 |             },
29 |           },
30 |         });
31 |       }
32 |     ).as('createToken');
33 |   });
34 | 
35 |   it('should load BasisTheory', () => {
36 |     cy.window().should('have.property', 'BasisTheory');
37 |   });
38 | 
39 |   it('should have all credit card form fields', () => {
40 |     cy.get('form').should('have.length', 1);
41 |     cy.get('form').find('#expiration_month').should('exist');
42 |     cy.get('form').find('#expiration_year').should('exist');
43 |     cy.get('form').find('#cvc').should('exist');
44 |   });
45 | 
46 |   it('should be able to submit form with minimum information and get masked information back', () => {
47 |     const year = (new Date().getFullYear() + 1).toString();
48 | 
49 |     cy.get('form').find('#card_number').type('4242424242424242');
50 |     cy.get('form').find('#expiration_month').type('10');
51 |     cy.get('form').find('#expiration_year').type(year);
52 |     cy.get('form').find('#cvc').type('123');
53 |     cy.get('form').submit();
54 | 
55 |     cy.wait('@createToken').then((i) => {
56 |       const alert = cy.stub();
57 | 
58 |       cy.on('window:alert', alert);
59 | 
60 |       cy.get('#cards_wrapper').children().should('have.length', 1);
61 |       cy.get('#cards_wrapper')
62 |         .find('.card-info')
63 |         .first()
64 |         .should('have.text', `${'X'.repeat(12)}4242`)
65 |         .next()
66 |         .should('contain.text', `10/${year}`)
67 |         .find('a')
68 |         .click()
69 |         .then(() => {
70 |           expect(alert.getCall(0)).to.be.calledWith(i.response.body.id);
71 |         });
72 |     });
73 |   });
74 | });
75 | 


--------------------------------------------------------------------------------
/cypress/e2e/elements.cy.ts:
--------------------------------------------------------------------------------
 1 | context('Elements example', () => {
 2 |   it('should load BasisTheoryElements dynamically', () => {
 3 |     cy.intercept(/https:\/\/.+?\/elements/u, {
 4 |       body: `
 5 |         window.BasisTheoryElements = {
 6 |           init: (apiKey, baseUrl) => {
 7 |             alert("BasisTheoryElements " + apiKey + " " + baseUrl);
 8 |           },
 9 |         };
10 |         if (window.BasisTheory) {
11 |           window.BasisTheory.elements = window.BasisTheoryElements;
12 |         }`,
13 |     });
14 |     cy.visit('cypress/fixtures/elements.html');
15 |     cy.on('window:alert', (val) => {
16 |       expect(val).to.equal(
17 |         `BasisTheoryElements 04ab9d12-4959-4c48-ba03-9ef722efcc5a https://js.basistheory.com`
18 |       );
19 |     });
20 |   });
21 |   it('should handle blocked BasisTheoryElements script request', () => {
22 |     cy.intercept(`http://cypress.test/events/initError`, (req) => {
23 |       req.reply({ body: req.body });
24 |     }).as(`initErrorEvent`);
25 |     cy.intercept(/https:\/\/.+?\/web-elements/u, {
26 |       statusCode: 400,
27 |     });
28 |     cy.visit('cypress/fixtures/elements.html');
29 |     cy.wait('@initErrorEvent')
30 |       .its('request.body')
31 |       .should(
32 |         'equal',
33 |         'Failed to deliver Elements script from Basis Theory. Check your network connection and try again or contact support@basistheory.com'
34 |       );
35 |   });
36 | });
37 | 


--------------------------------------------------------------------------------
/cypress/e2e/logs.cy.ts:
--------------------------------------------------------------------------------
1 | // eslint-disable-next-line spaced-comment
2 | ///  <reference path="../support/index.d.ts" />
3 | 
4 | context('Logs', () => {
5 |   it('should list', () => {
6 |     cy.testList('logs');
7 |   });
8 | });
9 | 


--------------------------------------------------------------------------------
/cypress/e2e/permissions.cy.ts:
--------------------------------------------------------------------------------
1 | // eslint-disable-next-line spaced-comment
2 | ///  <reference path="../support/index.d.ts" />
3 | 
4 | context('Permissions', () => {
5 |   it('should list', () => {
6 |     cy.testList('permissions');
7 |   });
8 | });
9 | 


--------------------------------------------------------------------------------
/cypress/e2e/proxies.cy.ts:
--------------------------------------------------------------------------------
 1 | // eslint-disable-next-line spaced-comment
 2 | ///  <reference path="../support/index.d.ts" />
 3 | 
 4 | context('Proxies', () => {
 5 |   it('should create', () => {
 6 |     cy.testCreate('proxies');
 7 |   });
 8 |   it('should retrieve', () => {
 9 |     cy.testRetrieve('proxies');
10 |   });
11 |   it('should update', () => {
12 |     cy.testUpdate('proxies');
13 |   });
14 |   it('should patch', () => {
15 |     cy.testPatch('proxies');
16 |   });
17 |   it('should delete', () => {
18 |     cy.testDelete('proxies');
19 |   });
20 |   it('should list', () => {
21 |     cy.testList('proxies');
22 |   });
23 | });
24 | 


--------------------------------------------------------------------------------
/cypress/e2e/reactor-formulas.cy.ts:
--------------------------------------------------------------------------------
 1 | // eslint-disable-next-line spaced-comment
 2 | ///  <reference path="../support/index.d.ts" />
 3 | 
 4 | context('Reactor Formulas', () => {
 5 |   it('should create', () => {
 6 |     cy.testCreate('reactor-formulas');
 7 |   });
 8 |   it('should retrieve', () => {
 9 |     cy.testRetrieve('reactor-formulas');
10 |   });
11 |   it('should update', () => {
12 |     cy.testUpdate('reactor-formulas');
13 |   });
14 |   it('should delete', () => {
15 |     cy.testDelete('reactor-formulas');
16 |   });
17 |   it('should list', () => {
18 |     cy.testList('reactor-formulas');
19 |   });
20 | });
21 | 


--------------------------------------------------------------------------------
/cypress/e2e/reactors.cy.ts:
--------------------------------------------------------------------------------
 1 | // eslint-disable-next-line spaced-comment
 2 | ///  <reference path="../support/index.d.ts" />
 3 | 
 4 | context('Reactors', () => {
 5 |   it('should create', () => {
 6 |     cy.testCreate('reactors');
 7 |   });
 8 |   it('should retrieve', () => {
 9 |     cy.testRetrieve('reactors');
10 |   });
11 |   it('should update', () => {
12 |     cy.testUpdate('reactors');
13 |   });
14 |   it('should patch', () => {
15 |     cy.testPatch('reactors');
16 |   });
17 |   it('should delete', () => {
18 |     cy.testDelete('reactors');
19 |   });
20 |   it('should list', () => {
21 |     cy.testList('reactors');
22 |   });
23 | });
24 | 


--------------------------------------------------------------------------------
/cypress/e2e/tenants.cy.ts:
--------------------------------------------------------------------------------
 1 | // eslint-disable-next-line spaced-comment
 2 | ///  <reference path="../support/index.d.ts" />
 3 | 
 4 | context('Tenants', () => {
 5 |   it('should retrieve', () => {
 6 |     cy.testRetrieveNoId('tenants/self');
 7 |   });
 8 |   it('should update', () => {
 9 |     cy.testUpdateNoId('tenants/self');
10 |   });
11 |   it('should delete', () => {
12 |     cy.testDeleteNoId('tenants/self');
13 |   });
14 | });
15 | 


--------------------------------------------------------------------------------
/cypress/e2e/tokens.cy.ts:
--------------------------------------------------------------------------------
 1 | // eslint-disable-next-line spaced-comment
 2 | ///  <reference path="../support/index.d.ts" />
 3 | 
 4 | context('Tokens', () => {
 5 |   it('should create', () => {
 6 |     cy.testCreate('tokens');
 7 |   });
 8 |   it('should retrieve', () => {
 9 |     cy.testRetrieve('tokens');
10 |   });
11 |   it('should update', () => {
12 |     cy.testUpdate('tokens', 'PATCH');
13 |   });
14 |   it('should delete', () => {
15 |     cy.testDelete('tokens');
16 |   });
17 |   it('should list', () => {
18 |     cy.testList('tokens');
19 |   });
20 | });
21 | 


--------------------------------------------------------------------------------
/cypress/fixtures/credit_card_api_error.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 |   <head>
 3 |     <title>Credit Card example</title>
 4 |     <!-- Add BasisTheory SDK -->
 5 |     <script src="../../dist/basis-theory-js.bundle.js"></script>
 6 |   </head>
 7 |   <body>
 8 |     <script>
 9 |       window.addEventListener('load', function () {
10 |         BasisTheory.init('123456789', { apiBaseUrl: 'http://localhost:3333' });
11 |       });
12 | 
13 |       function onSubmit($event) {
14 |         $event.preventDefault();
15 | 
16 |         const number = document.getElementById('card_number').value;
17 |         const expiration_month = document.getElementById('expiration_month')
18 |           .value;
19 |         const expiration_year = document.getElementById('expiration_year')
20 |           .value;
21 |         const cvc = document.getElementById('cvc').value;
22 |         const response = document.getElementById('response');
23 | 
24 |         const card = {
25 |           number,
26 |           expiration_month,
27 |           expiration_year,
28 |           cvc,
29 |         };
30 | 
31 |         BasisTheory.tokens
32 |           .create({
33 |             type: 'card',
34 |             data: card,
35 |           })
36 |           .then(function (data) {
37 |             // should not fall into here
38 |           })
39 |           .catch(function (error) {
40 |             response.innerHTML = JSON.stringify(error);
41 |           });
42 |       }
43 |     </script>
44 | 
45 |     <div id="response"></div>
46 |     <form onsubmit="onSubmit(event); return false;">
47 |       <h2 class="header">Add New Credit Card</h2>
48 |       <div>
49 |         <label for="card_number" class="mr-1">Card Number:</label>
50 |         <input
51 |           type="text"
52 |           id="card_number"
53 |           name="card_number"
54 |           class="span2"
55 |           maxlength="16"
56 |           required
57 |         />
58 |       </div>
59 |       <div>
60 |         <label for="expiration_month" class="mr-1">Expiration:</label>
61 |         <input
62 |           type="number"
63 |           id="expiration_month"
64 |           name="expiration_month"
65 |           size="2"
66 |           min="1"
67 |           max="12"
68 |           required
69 |         />/
70 |         <input
71 |           type="number"
72 |           id="expiration_year"
73 |           name="expiration_year"
74 |           size="2"
75 |           min="1990"
76 |           max="9999"
77 |           required
78 |         />
79 |         <label for="cvc" class="mr-1">CVC:</label>
80 |         <input
81 |           type="text"
82 |           id="cvc"
83 |           name="cvc"
84 |           minlength="3"
85 |           maxlength="4"
86 |           size="3"
87 |         />
88 |       </div>
89 |       <div class="submit">
90 |         <input type="submit" value="Add Card" class="button" />
91 |       </div>
92 |     </form>
93 |   </body>
94 | </html>
95 | 


--------------------------------------------------------------------------------
/cypress/fixtures/crud_client.html:
--------------------------------------------------------------------------------
  1 | <html>
  2 |   <head>
  3 |     <!-- Add BasisTheory SDK -->
  4 |     <script src="../../dist/basis-theory-js.bundle.js"></script>
  5 |   </head>
  6 | 
  7 |   <body>
  8 |     <script>
  9 |       let bt;
 10 |       window.addEventListener('load', async function () {
 11 |         bt = await BasisTheory.init('123456789');
 12 |       });
 13 | 
 14 |       function kebabToCamel(str) {
 15 |         let arr = str.split('-');
 16 |         let capital = arr.map((item, index) =>
 17 |           index
 18 |             ? item.charAt(0).toUpperCase() + item.slice(1).toLowerCase()
 19 |             : item.toLowerCase()
 20 |         );
 21 |         let capitalString = capital.join('');
 22 |         return capitalString;
 23 |       }
 24 | 
 25 |       function slashToCamel(str) {
 26 |         let arr = str.split('/');
 27 | 
 28 |         if (arr[1] === 'self') {
 29 |           return arr[0];
 30 |         }
 31 | 
 32 |         let capital = arr.map((item, index) =>
 33 |           index
 34 |             ? item.charAt(0).toUpperCase() + item.slice(1).toLowerCase()
 35 |             : item.toLowerCase()
 36 |         );
 37 |         let capitalString = capital.join('');
 38 |         return capitalString;
 39 |       }
 40 | 
 41 |       function submit() {
 42 |         let serviceName = document.getElementById('service').value;
 43 | 
 44 |         if (serviceName.indexOf('-') !== -1) {
 45 |           serviceName = kebabToCamel(serviceName);
 46 |         } else if (serviceName.indexOf('/') !== -1) {
 47 |           serviceName = slashToCamel(serviceName);
 48 |         }
 49 | 
 50 |         if (document.getElementById('create').checked) {
 51 |           bt[serviceName].create({});
 52 |         }
 53 |         if (document.getElementById('retrieve').checked) {
 54 |           bt[serviceName].retrieve('1234567890');
 55 |         }
 56 |         if (document.getElementById('update').checked) {
 57 |           bt[serviceName].update('1234567890', {});
 58 |         }
 59 |         if (document.getElementById('patch').checked) {
 60 |           bt[serviceName].patch('1234567890', {});
 61 |         }
 62 |         if (document.getElementById('delete').checked) {
 63 |           bt[serviceName].delete('1234567890');
 64 |         }
 65 |         if (document.getElementById('retrieve-no-id').checked) {
 66 |           bt[serviceName].retrieve();
 67 |         }
 68 |         if (document.getElementById('update-no-id').checked) {
 69 |           bt[serviceName].update({});
 70 |         }
 71 |         if (document.getElementById('delete-no-id').checked) {
 72 |           bt[serviceName].delete();
 73 |         }
 74 |         if (document.getElementById('list').checked) {
 75 |           bt[serviceName].list();
 76 |         }
 77 |       }
 78 |     </script>
 79 |     <div>
 80 |       <input type="checkbox" id="create" />
 81 |       <label for="create">Create</label>
 82 |       <input type="checkbox" id="retrieve" />
 83 |       <label for="retrieve">Retrieve</label>
 84 |       <input type="checkbox" id="update" />
 85 |       <label for="update">Update</label>
 86 |       <input type="checkbox" id="patch" />
 87 |       <label for="patch">Patch</label>
 88 |       <input type="checkbox" id="delete" />
 89 |       <label for="delete">Delete</label>
 90 |       <input type="checkbox" id="retrieve-no-id" />
 91 |       <label for="retrieve-no-id">Retrieve No Id</label>
 92 |       <input type="checkbox" id="update-no-id" />
 93 |       <label for="update-no-id">Update No Id</label>
 94 |       <input type="checkbox" id="delete-no-id" />
 95 |       <label for="delete-no-id">Delete No Id</label>
 96 |       <input type="checkbox" id="list" />
 97 |       <label for="List">List</label>
 98 |       <input type="text" placeholder="Service" id="service" />
 99 |       <button type="button" id="submit" onclick="submit()">submit</button>
100 |     </div>
101 |   </body>
102 | </html>
103 | 


--------------------------------------------------------------------------------
/cypress/fixtures/elements.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |   <head>
 4 |     <title>Elements example</title>
 5 |     <script src="../../dist/basis-theory-js.bundle.js"></script>
 6 |     <script src="./event-informer.js"></script>
 7 |   </head>
 8 |   <body>
 9 |     <script>
10 |       window.addEventListener('load', async () => {
11 |         try {
12 |           await BasisTheory.init('04ab9d12-4959-4c48-ba03-9ef722efcc5a', {
13 |             elements: true,
14 |           });
15 |         } catch (error) {
16 |           informEventCypress(error?.message || error, 'initError');
17 |         }
18 |       });
19 |     </script>
20 |   </body>
21 | </html>
22 | 


--------------------------------------------------------------------------------
/cypress/fixtures/event-informer.js:
--------------------------------------------------------------------------------
 1 | window.informEventCypress = (event, type = event.type) => {
 2 |   if (window.Cypress) {
 3 |     return fetch(`http://cypress.test/events/${type}`, {
 4 |       body: JSON.stringify(event),
 5 |       method: 'POST',
 6 |       headers: {
 7 |         'Content-Type': 'application/json',
 8 |       },
 9 |     });
10 |   }
11 | 
12 |   return Promise.resolve();
13 | };
14 | 


--------------------------------------------------------------------------------
/cypress/support/commands.ts:
--------------------------------------------------------------------------------
  1 | Cypress.Commands.add('testCreate', (serviceName: string) => {
  2 |   cy.intercept('POST', `/${serviceName}`, {}).as('create');
  3 | 
  4 |   cy.visit('./cypress/fixtures/crud_client.html');
  5 | 
  6 |   cy.get('#service').type(serviceName);
  7 |   cy.get('#create').click();
  8 | 
  9 |   cy.get('#submit').click();
 10 | 
 11 |   cy.wait('@create');
 12 | });
 13 | 
 14 | Cypress.Commands.add('testRetrieve', (serviceName: string) => {
 15 |   cy.intercept('GET', new RegExp(`/${serviceName}/.+`, 'u'), {}).as('retrieve');
 16 | 
 17 |   cy.visit('./cypress/fixtures/crud_client.html');
 18 | 
 19 |   cy.get('#service').type(serviceName);
 20 |   cy.get('#retrieve').click();
 21 | 
 22 |   cy.get('#submit').click();
 23 | 
 24 |   cy.wait('@retrieve');
 25 | });
 26 | 
 27 | Cypress.Commands.add(
 28 |   'testUpdate',
 29 |   (serviceName: string, method: 'PUT' | 'PATCH' = 'PUT') => {
 30 |     cy.intercept(method, new RegExp(`/${serviceName}/.+`, 'u'), {}).as(
 31 |       'update'
 32 |     );
 33 | 
 34 |     cy.visit('./cypress/fixtures/crud_client.html');
 35 | 
 36 |     cy.get('#service').type(serviceName);
 37 |     cy.get('#update').click();
 38 | 
 39 |     cy.get('#submit').click();
 40 | 
 41 |     cy.wait('@update');
 42 |   }
 43 | );
 44 | 
 45 | Cypress.Commands.add('testPatch', (serviceName: string) => {
 46 |   cy.intercept('PATCH', new RegExp(`/${serviceName}/.+`, 'u'), {}).as('patch');
 47 | 
 48 |   cy.visit('./cypress/fixtures/crud_client.html');
 49 | 
 50 |   cy.get('#service').type(serviceName);
 51 |   cy.get('#patch').click();
 52 | 
 53 |   cy.get('#submit').click();
 54 | 
 55 |   cy.wait('@patch');
 56 | });
 57 | 
 58 | Cypress.Commands.add('testDelete', (serviceName: string) => {
 59 |   cy.intercept('DELETE', new RegExp(`/${serviceName}/.+`, 'u'), {}).as(
 60 |     'delete'
 61 |   );
 62 | 
 63 |   cy.visit('./cypress/fixtures/crud_client.html');
 64 | 
 65 |   cy.get('#service').type(serviceName);
 66 |   cy.get('#delete').click();
 67 | 
 68 |   cy.get('#submit').click();
 69 | 
 70 |   cy.wait('@delete');
 71 | });
 72 | 
 73 | Cypress.Commands.add('testRetrieveNoId', (serviceName: string) => {
 74 |   cy.intercept('GET', `/${serviceName}`, {}).as('retrieve');
 75 | 
 76 |   cy.visit('./cypress/fixtures/crud_client.html');
 77 | 
 78 |   cy.get('#service').type(serviceName);
 79 |   cy.get('#retrieve-no-id').click();
 80 | 
 81 |   cy.get('#submit').click();
 82 | 
 83 |   cy.wait('@retrieve');
 84 | });
 85 | 
 86 | Cypress.Commands.add('testUpdateNoId', (serviceName: string) => {
 87 |   cy.intercept('PUT', `/${serviceName}`, {}).as('update');
 88 | 
 89 |   cy.visit('./cypress/fixtures/crud_client.html');
 90 | 
 91 |   cy.get('#service').type(serviceName);
 92 |   cy.get('#update-no-id').click();
 93 | 
 94 |   cy.get('#submit').click();
 95 | 
 96 |   cy.wait('@update');
 97 | });
 98 | 
 99 | Cypress.Commands.add('testDeleteNoId', (serviceName: string) => {
100 |   cy.intercept('DELETE', `/${serviceName}`, {}).as('delete');
101 | 
102 |   cy.visit('./cypress/fixtures/crud_client.html');
103 | 
104 |   cy.get('#service').type(serviceName);
105 |   cy.get('#delete-no-id').click();
106 | 
107 |   cy.get('#submit').click();
108 | 
109 |   cy.wait('@delete');
110 | });
111 | 
112 | Cypress.Commands.add('testList', (serviceName: string) => {
113 |   cy.intercept('GET', `/${serviceName}/`, {}).as('list');
114 | 
115 |   cy.visit('./cypress/fixtures/crud_client.html');
116 | 
117 |   cy.get('#service').type(serviceName);
118 |   cy.get('#list').click();
119 | 
120 |   cy.get('#submit').click();
121 | 
122 |   cy.wait('@list');
123 | });
124 | 


--------------------------------------------------------------------------------
/cypress/support/e2e.ts:
--------------------------------------------------------------------------------
1 | import './commands';
2 | 


--------------------------------------------------------------------------------
/cypress/support/index.d.ts:
--------------------------------------------------------------------------------
 1 | // eslint-disable-next-line spaced-comment
 2 | /// <reference types="cypress" />
 3 | 
 4 | declare namespace Cypress {
 5 |   interface Chainable {
 6 |     testCreate(serviceName: string);
 7 |     testRetrieve(serviceName: string);
 8 |     testUpdate(serviceName: string, method?: 'PUT' | 'PATCH');
 9 |     testPatch(serviceName: string);
10 |     testDelete(serviceName: string);
11 |     testRetrieveNoId(serviceName: string);
12 |     testUpdateNoId(serviceName: string);
13 |     testDeleteNoId(serviceName: string);
14 |     testList(serviceName: string);
15 |   }
16 | }
17 | 


--------------------------------------------------------------------------------
/cypress/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "target": "es6",
 4 |     "lib": ["es6", "dom"],
 5 |     "types": ["cypress"],
 6 |     "moduleResolution": "node"
 7 |   },
 8 |   "include": ["./**/*.ts"]
 9 | }
10 | 


--------------------------------------------------------------------------------
/examples/credit_card.html:
--------------------------------------------------------------------------------
  1 | <html>
  2 |   <head>
  3 |     <title>Credit Card example</title>
  4 |     <!-- Add BasisTheory SDK -->
  5 |     <script src="https://js.basistheory.com/"></script>
  6 |   </head>
  7 |   <body>
  8 |     <style>
  9 |       .header {
 10 |         grid-column: span 3;
 11 |       }
 12 |       .mr-1 {
 13 |         margin-right: 1em;
 14 |       }
 15 |       form {
 16 |         max-width: 480px;
 17 |       }
 18 |       .submit {
 19 |         display: flex;
 20 |         justify-content: flex-end;
 21 |       }
 22 |       .cards {
 23 |         display: flex;
 24 |         flex-wrap: wrap;
 25 |       }
 26 |       .card {
 27 |         min-width: 400px;
 28 |         background-color: #eee;
 29 |         border: 1px solid #ccc;
 30 |         padding: 1em;
 31 |         margin: 1em;
 32 |         border-radius: 1em;
 33 |       }
 34 |       .card-info {
 35 |         display: flex;
 36 |         justify-content: space-between;
 37 |       }
 38 |     </style>
 39 |     <script>
 40 |       // you can initialize the library whenever it is more suitable to you
 41 |       // here we are doing it when the window is properly loaded
 42 |       window.addEventListener('load', function () {
 43 |         BasisTheory.init('123456789'); // pass your API key
 44 |         // or
 45 |         // window.BasisTheory.init('123456789');
 46 |       });
 47 | 
 48 |       // listener for form submit event
 49 |       function onSubmit($event) {
 50 |         // tell the user agent not to handle the event
 51 |         $event.preventDefault();
 52 | 
 53 |         // get the underlying event target (our credit card form)
 54 |         const form = $event.target;
 55 | 
 56 |         // extract data from form elements
 57 |         const number = document.getElementById('card_number').value;
 58 |         const expiration_month = document.getElementById('expiration_month')
 59 |           .value;
 60 |         const expiration_year = document.getElementById('expiration_year')
 61 |           .value;
 62 |         const cvc = document.getElementById('cvc').value;
 63 | 
 64 |         const card = {
 65 |           number,
 66 |           expiration_month,
 67 |           expiration_year,
 68 |           cvc,
 69 |         };
 70 | 
 71 |         // this is where the magic happens
 72 |         // invoke async BasisTheory Create Tokens API
 73 |         BasisTheory.tokens
 74 |           .create({
 75 |             type: 'card',
 76 |             data: card,
 77 |           })
 78 |           .then(function (data) {
 79 |             // and when that is done
 80 |             form.reset(); // we can reset our form
 81 |             handleNewCard(data); // and attach the stored credit card info to the view
 82 |           });
 83 |       }
 84 | 
 85 |       function handleNewCard(card) {
 86 |         const wrapper = document.getElementById('cards_wrapper');
 87 |         const newCardDiv = document.createElement('div');
 88 |         const expiration =
 89 |           card.data.expiration_month + '/' + card.data.expiration_year;
 90 |         newCardDiv.className = 'card';
 91 |         newCardDiv.innerHTML =
 92 |           '<h3>' +
 93 |           name +
 94 |           '</h3>' +
 95 |           '<div class="card-info">' +
 96 |           card.data.number +
 97 |           '</div>' +
 98 |           '<div class="card-info">' +
 99 |           '<span>' +
100 |           expiration +
101 |           '</span>' +
102 |           '<a href="#" onclick="alert(\'' +
103 |           card.id +
104 |           '\'); return true;">see token</a>' +
105 |           '</div>';
106 |         wrapper.appendChild(newCardDiv);
107 |       }
108 |     </script>
109 | 
110 |     <!-- This is where our stored credit cards will go -->
111 |     <div id="cards_wrapper" class="cards"></div>
112 |     <hr />
113 |     <!-- We don't want the form to reload the page; hence `return false` -->
114 |     <form onsubmit="onSubmit(event); return false;">
115 |       <h2 class="header">Add New Credit Card</h2>
116 |       <div>
117 |         <label for="card_number" class="mr-1">Card Number:</label>
118 |         <input
119 |           type="text"
120 |           id="card_number"
121 |           name="card_number"
122 |           class="span2"
123 |           maxlength="16"
124 |           required
125 |         />
126 |       </div>
127 |       <div>
128 |         <label for="expiration_month" class="mr-1">Expiration:</label>
129 |         <input
130 |           type="number"
131 |           id="expiration_month"
132 |           name="expiration_month"
133 |           size="2"
134 |           min="1"
135 |           max="12"
136 |           required
137 |         />/
138 |         <input
139 |           type="number"
140 |           id="expiration_year"
141 |           name="expiration_year"
142 |           size="2"
143 |           min="1990"
144 |           max="9999"
145 |           required
146 |         />
147 |         <label for="cvc" class="mr-1">CVC:</label>
148 |         <input
149 |           type="text"
150 |           id="cvc"
151 |           name="cvc"
152 |           minlength="3"
153 |           maxlength="4"
154 |           size="3"
155 |         />
156 |       </div>
157 |       <div class="submit">
158 |         <input type="submit" value="Add Card" class="button" />
159 |       </div>
160 |     </form>
161 |   </body>
162 | </html>
163 | 


--------------------------------------------------------------------------------
/jest.config.js:
--------------------------------------------------------------------------------
 1 | const { pathsToModuleNameMapper } = require('ts-jest');
 2 | const { compilerOptions } = require('./tsconfig');
 3 | 
 4 | const common = {
 5 |   automock: false,
 6 |   coveragePathIgnorePatterns: ['test', 'dist'],
 7 |   transform: { '^.+\\.(t|j)sx?$': ['@swc/jest'] },
 8 |   testPathIgnorePatterns: ['cypress'],
 9 |   roots: ['<rootDir>'],
10 |   modulePaths: ['<rootDir>'],
11 |   moduleNameMapper: pathsToModuleNameMapper(compilerOptions.paths),
12 | };
13 | 
14 | module.exports = {
15 |   projects: [
16 |     {
17 |       ...common,
18 |       displayName: 'jsdom',
19 |       testEnvironment: 'jsdom',
20 |     },
21 |     {
22 |       ...common,
23 |       displayName: 'node',
24 |       testEnvironment: 'node',
25 |     },
26 |   ],
27 |   coverageThreshold: {
28 |     global: {
29 |       statements: 80,
30 |       branches: 80,
31 |       lines: 80,
32 |       functions: 80,
33 |     },
34 |   },
35 | };
36 | 


--------------------------------------------------------------------------------
/makefile:
--------------------------------------------------------------------------------
 1 | MAKEFLAGS += --silent
 2 | 
 3 | verify:
 4 | 	./scripts/verify.sh
 5 | 
 6 | build:
 7 | 	./scripts/build.sh
 8 | 
 9 | acceptance:
10 | 	./scripts/acceptance.sh
11 | 
12 | setup-infra:
13 | 	./scripts/setupinfra.sh
14 | 
15 | release:
16 | 	yarn release
17 | 	$(MAKE) setup-infra
18 | 
19 | write-lib-vars:
20 | 	./scripts/writelibvars.sh
21 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "name": "@basis-theory/basis-theory-js",
  3 |   "version": "4.28.2",
  4 |   "repository": "https://github.com/Basis-Theory/basis-theory-js",
  5 |   "license": "Apache-2.0",
  6 |   "author": {
  7 |     "name": "Basis Theory",
  8 |     "email": "support@basistheory.com"
  9 |   },
 10 |   "main": "dist/index.js",
 11 |   "module": "dist/index.js",
 12 |   "typings": "dist/index.d.ts",
 13 |   "files": [
 14 |     "dist"
 15 |   ],
 16 |   "prettier": "@basis-theory/eslint-config/prettier",
 17 |   "scripts": {
 18 |     "analyze": "size-limit --why",
 19 |     "build": "yarn clean && concurrently 'yarn build:bundle' 'yarn build:module' 'yarn build:declarations' 'yarn build:package' -n 'bundle,module,declarations,package' -c 'yellow,magenta,blue,green' --kill-others-on-fail -g",
 20 |     "build:bundle": "webpack --config webpack.prod.js",
 21 |     "build:declarations": "tsc && tsc-alias",
 22 |     "build:module": "babel src --extensions .ts --out-dir dist",
 23 |     "build:package": "node prepare.js",
 24 |     "clean": "rimraf dist",
 25 |     "cypress:ci": "cypress run --headless -b chrome",
 26 |     "cypress:open": "cypress open",
 27 |     "lint": "eslint . --quiet --ignore-path .gitignore",
 28 |     "lint:fix": "eslint . --fix --ignore-path .gitignore",
 29 |     "prepare": "yarn build",
 30 |     "release": "semantic-release",
 31 |     "size": "size-limit",
 32 |     "start": "webpack --config webpack.dev.js --watch",
 33 |     "test": "jest",
 34 |     "test:cov": "jest --coverage",
 35 |     "test:e2e": "yarn cypress:ci",
 36 |     "pretty-quick": "pretty-quick --staged",
 37 |     "postinstall": "husky install"
 38 |   },
 39 |   "dependencies": {
 40 |     "axios": "^1.8.2",
 41 |     "camelcase-keys": "^6.2.2",
 42 |     "csstype": "^3.0.11",
 43 |     "os": "^0.1.2",
 44 |     "os-browserify": "^0.3.0",
 45 |     "snake-case": "^3.0.4",
 46 |     "snakecase-keys": "^3.2.1"
 47 |   },
 48 |   "devDependencies": {
 49 |     "@babel/cli": "^7.22.15",
 50 |     "@babel/core": "^7.15.8",
 51 |     "@babel/plugin-proposal-class-properties": "^7.12.13",
 52 |     "@babel/plugin-transform-arrow-functions": "^7.12.13",
 53 |     "@babel/plugin-transform-runtime": "^7.22.15",
 54 |     "@babel/preset-env": "^7.16.5",
 55 |     "@babel/preset-typescript": "^7.12.13",
 56 |     "@basis-theory/eslint-config": "^1.0.13",
 57 |     "@commitlint/cli": "^12.1.1",
 58 |     "@commitlint/config-conventional": "^17.6.3",
 59 |     "@peculiar/webcrypto": "^1.4.3",
 60 |     "@semantic-release/changelog": "^6.0.3",
 61 |     "@semantic-release/commit-analyzer": "^8.0.1",
 62 |     "@semantic-release/exec": "^6.0.3",
 63 |     "@semantic-release/git": "^9.0.0",
 64 |     "@semantic-release/github": "^8.0.5",
 65 |     "@semantic-release/npm": "^7.0.10",
 66 |     "@semantic-release/release-notes-generator": "^10.0.3",
 67 |     "@size-limit/preset-small-lib": "^7.0.5",
 68 |     "@swc/core": "^1.3.75",
 69 |     "@swc/jest": "^0.2.28",
 70 |     "@types/chance": "^1.1.3",
 71 |     "@types/dotenv-webpack": "^7.0.4",
 72 |     "@types/eccrypto": "^1.1.5",
 73 |     "@types/is-base64": "^1.1.1",
 74 |     "@types/jest": "^27.4.0",
 75 |     "@types/uuid": "^8.3.3",
 76 |     "axios-mock-adapter": "^1.21.2",
 77 |     "babel-loader": "^8.2.2",
 78 |     "babel-plugin-inline-dotenv": "^1.1.0",
 79 |     "babel-plugin-transform-builtin-extend": "^1.1.2",
 80 |     "babel-plugin-tsconfig-paths-module-resolver": "^1.0.3",
 81 |     "chance": "^1.1.11",
 82 |     "concurrently": "^8.2.2",
 83 |     "cypress": "^12.16.0",
 84 |     "dotenv-webpack": "^8.0.1",
 85 |     "eslint": "^7.32.0",
 86 |     "husky": "^8.0.1",
 87 |     "is-base64": "^1.1.0",
 88 |     "jest": "^29.5.0",
 89 |     "jest-environment-jsdom": "^29.5.0",
 90 |     "prettier": "^2.2.1",
 91 |     "pretty-quick": "^3.1.3",
 92 |     "rimraf": "^3.0.2",
 93 |     "semantic-release": "^19.0.3",
 94 |     "size-limit": "^7.0.5",
 95 |     "ts-jest": "^29.1.1",
 96 |     "tsc-alias": "^1.7.0",
 97 |     "tsconfig-paths-webpack-plugin": "^3.5.2",
 98 |     "typescript": "^5.0.4",
 99 |     "uuid": "^8.3.2",
100 |     "webpack": "^5.84.1",
101 |     "webpack-bundle-analyzer": "^4.9.0",
102 |     "webpack-cli": "^4.10.0",
103 |     "webpack-merge": "^5.8.0"
104 |   },
105 |   "resolutions": {
106 |     "glob-parent": "^5.1.2",
107 |     "postcss": "^8.4.31",
108 |     "normalize-url": "^5.3.1",
109 |     "is-svg": "^4.2.2",
110 |     "yargs-parser": "^21.0.0",
111 |     "mem": "^4.0.0",
112 |     "semver-regex": "^3.1.4",
113 |     "tmpl": "^1.0.5",
114 |     "tar": "^4.4.19",
115 |     "minimist": "^1.2.6",
116 |     "json-schema": "^0.4.0",
117 |     "terser": "^5.14.2",
118 |     "word-wrap": "^1.2.5"
119 |   },
120 |   "engines": {
121 |     "node": ">=10.12.0"
122 |   },
123 |   "publishConfig": {
124 |     "access": "public"
125 |   },
126 |   "size-limit": [
127 |     {
128 |       "path": "dist/basis-theory-js.bundle.js",
129 |       "limit": "50 KB"
130 |     }
131 |   ]
132 | }
133 | 


--------------------------------------------------------------------------------
/prepare.js:
--------------------------------------------------------------------------------
 1 | const fs = require('fs');
 2 | const libPackage = require('./package.json');
 3 | 
 4 | // remove not required fields
 5 | delete libPackage.devDependencies;
 6 | delete libPackage['size-limit'];
 7 | delete libPackage.prettier;
 8 | 
 9 | // use only required temporary script in dist
10 | libPackage.scripts = {
11 |   postversion: 'cd .. && node bump.js',
12 | };
13 | 
14 | // include all 'dist/*' files, but bundles
15 | libPackage.files = ['*', '!*.bundle.js'];
16 | 
17 | // updates source flags removing 'dist' path
18 | ['main', 'module', 'typings'].forEach((prop) => {
19 |   libPackage[prop] = libPackage[prop].replace('dist/', '');
20 | });
21 | 
22 | fs.mkdirSync('./dist', { recursive: true });
23 | fs.copyFileSync('README.md', './dist/README.md');
24 | fs.copyFileSync('LICENSE', './dist/LICENSE');
25 | fs.writeFileSync(
26 |   './dist/package.json',
27 |   JSON.stringify(libPackage, undefined, 2)
28 | );
29 | 


--------------------------------------------------------------------------------
/scripts/acceptance.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | set -e
 3 | 
 4 | current_directory="$PWD"
 5 | 
 6 | cd $(dirname $0)/..
 7 | 
 8 | yarn lint
 9 | 
10 | # unit
11 | yarn test --coverage
12 | # e2e
13 | yarn test:e2e
14 | 
15 | result=$?
16 | 
17 | cd "$current_directory"
18 | 
19 | exit $result
20 | 


--------------------------------------------------------------------------------
/scripts/build.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | set -e
 3 | 
 4 | current_directory="$PWD"
 5 | 
 6 | cd $(dirname $0)
 7 | 
 8 | if [ "$SKIP_INSTALL" = true ] || [ "$SKIP_INSTALL" = 1 ]
 9 | then
10 |   echo SKIP_INSTALL is set, skipping dependency installation...
11 | else
12 |   yarn install --frozen-lockfile
13 | fi
14 | 
15 | yarn build
16 | 
17 | cd "$current_directory"
18 | 


--------------------------------------------------------------------------------
/scripts/setupinfra.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | set -e
 3 | 
 4 | script_directory="$PWD"
 5 | 
 6 | # get bundle source
 7 | cd $(dirname $0)/../dist
 8 | dist_directory="$PWD"
 9 | 
10 | # back to script directory
11 | cd $script_directory
12 | 
13 | if [[ -z "${ENVIRONMENT}" ]]; then
14 |     echo "environment variable is not set"
15 |     exit 1
16 | fi
17 | 
18 | if [ "${ENVIRONMENT}" = dev  ]; then
19 |     JS_HOST="js.flock-dev.com"
20 | else
21 |     JS_HOST="js.basistheory.com"
22 | fi
23 | 
24 | MAJOR_VERSION=$(cat package.json | jq -r '.version' | cut -d. -f1)
25 | BUNDLE_PATH=$dist_directory/basis-theory-js.bundle.js
26 | BLOB_DIR=v$MAJOR_VERSION
27 | INDEX_JS_NAME=$BLOB_DIR/index.js
28 | VERSIONED_JS_NAME=$(cat package.json | jq -r '.version')
29 | # create script hash file to be used in sub-resource integrity checks, i.e.
30 | # https://developer.mozilla.org/en-US/docs/Web/Security/Subresource_Integrity#using_shasum
31 | JS_HASH_PATH=$BUNDLE_PATH-hash
32 | shasum -b -a 384 $dist_directory/basis-theory-js.bundle.js | awk '{ print $1 }' | xxd -r -p | base64 > $JS_HASH_PATH
33 | 
34 | echo "Uploading bundle to $JS_HOST/$INDEX_JS_NAME"
35 | 
36 | if [[ -z ${AWS} ]]; then
37 |   JS_BUCKET_NAME=$(aws s3 cp s3://basis-theory-tf-state/basistheory-cloudflare/$ENVIRONMENT/terraform.tfstate - | jq -r .outputs.js_bucket_name.value)
38 | else
39 |   JS_BUCKET_NAME="${ENVIRONMENT}-${JS_HOST}"
40 | fi
41 | 
42 | # Upload Content
43 | aws s3 cp --acl public-read "$BUNDLE_PATH" s3://"${JS_BUCKET_NAME}"/"${INDEX_JS_NAME}"
44 | aws s3 cp --acl public-read --content-type text/plain "$JS_HASH_PATH" s3://"${JS_BUCKET_NAME}"/"${INDEX_JS_NAME}-hash"
45 | 
46 | if [ "$IS_PR_WORKFLOW" = true ] ; then
47 |   BLOB_NAME=$BLOB_DIR/$(git rev-parse HEAD).js
48 | 
49 |   echo "Uploading bundle to $JS_HOST/$BLOB_NAME"
50 | 
51 |   aws s3 cp --acl public-read "$BUNDLE_PATH" s3://"${JS_BUCKET_NAME}"/"${BLOB_NAME}"
52 |   aws s3 cp --acl public-read "$JS_HASH_PATH" s3://"${JS_BUCKET_NAME}"/"${BLOB_NAME}-hash"
53 | else
54 |   echo "Uploading bundle to $JS_HOST/$VERSIONED_JS_NAME"
55 | 
56 |   aws s3 cp --acl public-read "$BUNDLE_PATH" s3://"${JS_BUCKET_NAME}"/"${VERSIONED_JS_NAME}"
57 |   aws s3 cp --acl public-read --content-type text/plain "$JS_HASH_PATH" s3://"${JS_BUCKET_NAME}"/"${VERSIONED_JS_NAME}-hash"
58 | fi
59 | 
60 | result=$?
61 | 
62 | cd "$script_directory"
63 | 
64 | exit $result
65 | 


--------------------------------------------------------------------------------
/scripts/verify.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | set -e
 3 | 
 4 | # verify the software
 5 | 
 6 | current_directory="$PWD"
 7 | 
 8 | cd $(dirname $0)
 9 | 
10 | time {
11 |     ./build.sh
12 |     ./acceptance.sh
13 | }
14 | 
15 | cd "$current_directory"
16 | 


--------------------------------------------------------------------------------
/scripts/writelibvars.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | set -e
 3 | 
 4 | current_directory="$PWD"
 5 | 
 6 | if [ "$ENVIRONMENT" = dev ]; then
 7 |   JS_HOST="js.flock-dev.com"
 8 |   API_HOST="api.flock-dev.com"
 9 |   ELEMENTS_HOST="js.flock-dev.com/hosted-elements"
10 | else
11 |   JS_HOST="js.basistheory.com"
12 |   API_HOST="api.basistheory.com"
13 |   ELEMENTS_HOST="js.basistheory.com/hosted-elements"
14 | fi
15 | 
16 | DD_TOKEN="pub5f53501515584007899577554c4aeda6"
17 | 
18 | printf 'JS_HOST=%s\n' "$JS_HOST" >> .env
19 | printf 'API_HOST=%s\n' "$API_HOST" >> .env
20 | printf 'ELEMENTS_HOST=%s\n' "$ELEMENTS_HOST" >> .env
21 | printf 'DD_TOKEN=%s\n' "$DD_TOKEN" >> .env
22 | printf 'DD_GIT_SHA=%s\n' "$DD_GIT_SHA" >> .env
23 | 
24 | result=$?
25 | 
26 | cd "$current_directory"
27 | 
28 | exit $result
29 | 


--------------------------------------------------------------------------------
/src/application-templates/BasisTheoryApplicationTemplates.ts:
--------------------------------------------------------------------------------
 1 | import { createRequestConfig, dataExtractor } from '@/common';
 2 | import { BasisTheoryService } from '@/service';
 3 | import { CrudBuilder } from '@/service/CrudBuilder';
 4 | import { ApplicationTemplate } from '@/types/models/application-templates';
 5 | import { RequestOptions } from '@/types/sdk';
 6 | 
 7 | export const BasisTheoryApplicationTemplates = new CrudBuilder(
 8 |   class BasisTheoryApplicationTemplates extends BasisTheoryService {
 9 |     public list(options?: RequestOptions): Promise<ApplicationTemplate[]> {
10 |       return this.client
11 |         .get('/', createRequestConfig(options))
12 |         .then(dataExtractor);
13 |     }
14 |   }
15 | )
16 |   .retrieve<ApplicationTemplate>()
17 |   .build();
18 | 
19 | export type BasisTheoryApplicationTemplates = InstanceType<
20 |   typeof BasisTheoryApplicationTemplates
21 | >;
22 | 


--------------------------------------------------------------------------------
/src/application-templates/index.ts:
--------------------------------------------------------------------------------
1 | export { BasisTheoryApplicationTemplates } from './BasisTheoryApplicationTemplates';
2 | 


--------------------------------------------------------------------------------
/src/applicationKeys/BasisTheoryApplicationKeys.ts:
--------------------------------------------------------------------------------
 1 | import { dataExtractor } from '@/common';
 2 | import { BasisTheoryService } from '@/service';
 3 | import { CrudBuilder } from '@/service/CrudBuilder';
 4 | import type { ApplicationKey } from '@/types/models';
 5 | 
 6 | export const BasisTheoryApplicationKeys = new CrudBuilder(
 7 |   class BasisTheoryApplicationKeys extends BasisTheoryService {
 8 |     public create(applicationId: string): Promise<ApplicationKey> {
 9 |       return this.client.post(`${applicationId}/keys`).then(dataExtractor);
10 |     }
11 | 
12 |     public get(applicationId: string): Promise<ApplicationKey[]> {
13 |       return this.client.get(`${applicationId}/keys`).then(dataExtractor);
14 |     }
15 | 
16 |     public getById(
17 |       applicationId: string,
18 |       keyId: string
19 |     ): Promise<ApplicationKey> {
20 |       return this.client
21 |         .get(`${applicationId}/keys/${keyId}`)
22 |         .then(dataExtractor);
23 |     }
24 | 
25 |     public delete(applicationId: string, keyId: string): Promise<void> {
26 |       return this.client
27 |         .delete(`${applicationId}/keys/${keyId}`)
28 |         .then(dataExtractor);
29 |     }
30 |   }
31 | ).build();
32 | 
33 | export type BasisTheoryApplicationKeys = InstanceType<
34 |   typeof BasisTheoryApplicationKeys
35 | >;
36 | 


--------------------------------------------------------------------------------
/src/applicationKeys/index.ts:
--------------------------------------------------------------------------------
1 | export { BasisTheoryApplicationKeys } from './BasisTheoryApplicationKeys';
2 | 


--------------------------------------------------------------------------------
/src/applications/BasisTheoryApplications.ts:
--------------------------------------------------------------------------------
 1 | import { createRequestConfig, dataExtractor } from '@/common';
 2 | import { BasisTheoryService } from '@/service';
 3 | import { CrudBuilder } from '@/service/CrudBuilder';
 4 | import type {
 5 |   Application,
 6 |   CreateApplication,
 7 |   UpdateApplication,
 8 | } from '@/types/models';
 9 | import type { ListApplicationsQuery, RequestOptions } from '@/types/sdk';
10 | 
11 | export const BasisTheoryApplications = new CrudBuilder(
12 |   class BasisTheoryApplications extends BasisTheoryService {
13 |     /**
14 |      * @deprecated use {@link retrieveByKey} instead
15 |      */
16 |     public getApplicationByKey(): Promise<Application> {
17 |       return this.retrieveByKey();
18 |     }
19 | 
20 |     public retrieveByKey(options?: RequestOptions): Promise<Application> {
21 |       return this.client
22 |         .get('/key', createRequestConfig(options))
23 |         .then(dataExtractor);
24 |     }
25 | 
26 |     /**
27 |      * @deprecated This method is deprecated. Use Terraform or https://portal.basistheory.com to manage keys instead.
28 |      */
29 |     public regenerateKey(
30 |       id: string,
31 |       options?: RequestOptions
32 |     ): Promise<Application> {
33 |       return this.client
34 |         .post(`${id}/regenerate`, undefined, createRequestConfig(options))
35 |         .then(dataExtractor);
36 |     }
37 |   }
38 | )
39 |   .create<Application, CreateApplication>()
40 |   .retrieve<Application>()
41 |   .update<Application, UpdateApplication>()
42 |   .delete()
43 |   .list<Application, ListApplicationsQuery>()
44 |   .build();
45 | 
46 | export type BasisTheoryApplications = InstanceType<
47 |   typeof BasisTheoryApplications
48 | >;
49 | 


--------------------------------------------------------------------------------
/src/applications/index.ts:
--------------------------------------------------------------------------------
1 | export { BasisTheoryApplications } from './BasisTheoryApplications';
2 | 


--------------------------------------------------------------------------------
/src/common/BasisTheoryApiError.ts:
--------------------------------------------------------------------------------
 1 | export class BasisTheoryApiError extends Error {
 2 |   public constructor(
 3 |     message: string,
 4 |     public readonly status: number,
 5 |     public readonly data?: unknown,
 6 |     public readonly _debug?: Record<string, unknown>
 7 |   ) {
 8 |     super(message);
 9 |     this.name = 'BasisTheoryApiError';
10 | 
11 |     Object.setPrototypeOf(this, BasisTheoryApiError.prototype);
12 |   }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/common/BasisTheoryValidationError.ts:
--------------------------------------------------------------------------------
 1 | import type { FieldError } from '@/types/elements';
 2 | 
 3 | export class BasisTheoryValidationError<
 4 |   // eslint-disable-next-line @typescript-eslint/no-explicit-any
 5 |   Details = Record<string, any>
 6 | > extends Error {
 7 |   public constructor(
 8 |     message: string,
 9 |     public readonly details: Details,
10 |     /**
11 |      * @deprecated use {@link details}
12 |      */
13 |     public readonly validation?: FieldError[]
14 |   ) {
15 |     super(message);
16 |     this.name = 'BasisTheoryValidationError';
17 | 
18 |     Object.setPrototypeOf(this, BasisTheoryValidationError.prototype);
19 |   }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/common/HttpClientError.ts:
--------------------------------------------------------------------------------
 1 | export class HttpClientError extends Error {
 2 |   public readonly status: number;
 3 | 
 4 |   public readonly data?: unknown;
 5 | 
 6 |   public readonly headers?: unknown;
 7 | 
 8 |   public constructor(
 9 |     message: string,
10 |     status: number,
11 |     data?: unknown,
12 |     headers?: unknown
13 |   ) {
14 |     super(message);
15 |     this.name = 'HttpClientError';
16 |     this.status = status;
17 |     this.data = data;
18 |     this.headers = headers;
19 | 
20 |     Object.setPrototypeOf(this, HttpClientError.prototype);
21 |   }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/common/constants.ts:
--------------------------------------------------------------------------------
  1 | import type { BasisTheoryServicesBasePathMap } from '@/types/sdk';
  2 | 
  3 | const WEB_ELEMENTS_VERSION = '1.7.2';
  4 | 
  5 | const API_KEY_HEADER = 'BT-API-KEY';
  6 | 
  7 | const BT_TRACE_ID_HEADER = 'bt-trace-id';
  8 | 
  9 | const CF_RAY_HEADER = 'cf-ray';
 10 | 
 11 | const BT_IDEMPOTENCY_KEY_HEADER = 'bt-idempotency-key';
 12 | 
 13 | const BT_EXPOSE_PROXY_RESPONSE_HEADER = 'BT-EXPOSE-RAW-PROXY-RESPONSE';
 14 | 
 15 | const CONTENT_TYPE_HEADER = 'Content-Type';
 16 | 
 17 | const MERGE_CONTENT_TYPE = 'application/merge-patch+json';
 18 | 
 19 | const USER_AGENT_HEADER = 'User-Agent';
 20 | 
 21 | const CLIENT_USER_AGENT_HEADER = 'BT-CLIENT-USER-AGENT';
 22 | 
 23 | const USER_AGENT_CLIENT = 'BasisTheoryJS';
 24 | 
 25 | const DEFAULT_BASE_URL = `https://${process.env.API_HOST}`;
 26 | 
 27 | const DEFAULT_ELEMENTS_BASE_URL = `https://${process.env.ELEMENTS_HOST}`;
 28 | 
 29 | const DD_TOKEN = process.env.DD_TOKEN;
 30 | 
 31 | const DD_GIT_SHA = process.env.DD_GIT_SHA;
 32 | 
 33 | const CLIENT_BASE_PATHS: BasisTheoryServicesBasePathMap = {
 34 |   tokens: 'tokens',
 35 |   tokenize: 'tokenize',
 36 |   applications: 'applications',
 37 |   applicationKeys: 'applications',
 38 |   applicationTemplates: 'application-templates',
 39 |   tenants: 'tenants/self',
 40 |   logs: 'logs',
 41 |   reactorFormulas: 'reactor-formulas',
 42 |   reactors: 'reactors',
 43 |   permissions: 'permissions',
 44 |   proxies: 'proxies',
 45 |   proxy: 'proxy',
 46 |   sessions: 'sessions',
 47 |   threeds: '3ds',
 48 |   tokenIntents: 'token-intents',
 49 | };
 50 | 
 51 | const BROWSER_LIST = [
 52 |   {
 53 |     browserName: 'Firefox',
 54 |     browserUA: 'Firefox',
 55 |   },
 56 |   {
 57 |     browserName: 'SamsungBrowser',
 58 |     browserUA: 'SamsungBrowser',
 59 |   },
 60 |   {
 61 |     browserName: 'Opera',
 62 |     browserUA: 'Opera',
 63 |   },
 64 |   {
 65 |     browserName: 'Opera',
 66 |     browserUA: 'OPR',
 67 |   },
 68 |   {
 69 |     browserName: 'Microsoft Internet Explorer',
 70 |     browserUA: 'Trident',
 71 |   },
 72 |   {
 73 |     browserName: 'Microsoft Edge (Legacy)',
 74 |     browserUA: 'Edge',
 75 |   },
 76 |   {
 77 |     browserName: 'Microsoft Edge (Chromium)',
 78 |     browserUA: 'Edg',
 79 |   },
 80 |   {
 81 |     browserName: 'Google Chrome/Chromium',
 82 |     browserUA: 'Chrome',
 83 |   },
 84 |   {
 85 |     browserName: 'Safari',
 86 |     browserUA: 'Safari',
 87 |   },
 88 | ];
 89 | 
 90 | export {
 91 |   API_KEY_HEADER,
 92 |   BROWSER_LIST,
 93 |   BT_EXPOSE_PROXY_RESPONSE_HEADER,
 94 |   BT_IDEMPOTENCY_KEY_HEADER,
 95 |   BT_TRACE_ID_HEADER,
 96 |   CF_RAY_HEADER,
 97 |   CLIENT_BASE_PATHS,
 98 |   CLIENT_USER_AGENT_HEADER,
 99 |   CONTENT_TYPE_HEADER,
100 |   DD_GIT_SHA,
101 |   DD_TOKEN,
102 |   DEFAULT_BASE_URL,
103 |   DEFAULT_ELEMENTS_BASE_URL,
104 |   MERGE_CONTENT_TYPE,
105 |   USER_AGENT_CLIENT,
106 |   USER_AGENT_HEADER,
107 |   WEB_ELEMENTS_VERSION,
108 | };
109 | 


--------------------------------------------------------------------------------
/src/common/index.ts:
--------------------------------------------------------------------------------
1 | export * from './constants';
2 | export * from './utils';
3 | export { BasisTheoryApiError } from './BasisTheoryApiError';
4 | export { BasisTheoryValidationError } from './BasisTheoryValidationError';
5 | export { HttpClientError } from './HttpClientError';
6 | 


--------------------------------------------------------------------------------
/src/common/logging.ts:
--------------------------------------------------------------------------------
 1 | import { DEFAULT_BASE_URL } from './constants';
 2 | 
 3 | export const logger = (() => {
 4 |   const ddTok = 'pubb96b84a13912504f4354f2d794ea4fab';
 5 | 
 6 |   let isTelemetryEnabled = process.env.NODE_ENV !== 'test';
 7 | 
 8 |   const log = async (
 9 |     message: string,
10 |     level: string,
11 |     attributes = {}
12 |   ): Promise<void> => {
13 |     if (!isTelemetryEnabled) {
14 |       return;
15 |     }
16 | 
17 |     try {
18 |       let env;
19 | 
20 |       if (DEFAULT_BASE_URL.includes('localhost')) {
21 |         env = 'local';
22 |       } else if (DEFAULT_BASE_URL.includes('dev')) {
23 |         env = 'dev';
24 |       } else {
25 |         env = 'prod';
26 |       }
27 | 
28 |       const payload = {
29 |         // dd info
30 |         level,
31 |         message,
32 | 
33 |         // for basis theory tracking
34 |         service: 'js-sdk',
35 |         env,
36 | 
37 |         // browser information
38 |         referrer: document?.referrer,
39 |         origin: window?.location?.origin,
40 |         url: window?.location?.href,
41 |         userAgent: navigator?.userAgent,
42 | 
43 |         // custom values
44 |         ...attributes,
45 |       };
46 | 
47 |       await fetch(`https://http-intake.logs.datadoghq.com/v1/input/${ddTok}`, {
48 |         method: 'POST',
49 |         body: JSON.stringify(payload),
50 |         headers: {
51 |           'Content-Type': 'application/json',
52 |         },
53 |       });
54 |     } catch {
55 |       // eslint-disable-next-line no-console
56 |       console.warn('There was an error sending telemetry.');
57 |     }
58 |   };
59 | 
60 |   const setTelemetryEnabled = (enabled: boolean): void => {
61 |     isTelemetryEnabled = enabled;
62 |   };
63 | 
64 |   return {
65 |     setTelemetryEnabled,
66 |     log: {
67 |       error: (message: string, attributes = {}) =>
68 |         log(message, 'error', attributes),
69 |       info: (message: string, attributes = {}) =>
70 |         log(message, 'info', attributes),
71 |       warn: (message: string, attributes = {}) =>
72 |         log(message, 'warn', attributes),
73 |     },
74 |   };
75 | })();
76 | 


--------------------------------------------------------------------------------
/src/elements/constants.ts:
--------------------------------------------------------------------------------
  1 | const ELEMENTS_INIT_ERROR_MESSAGE =
  2 |   'BasisTheory Elements was not properly initialized.';
  3 | 
  4 | const ELEMENTS_NOM_DOM_ERROR_MESSAGE =
  5 |   'Tried to load BasisTheoryElements in a non-DOM environment.';
  6 | 
  7 | const ELEMENTS_SCRIPT_LOAD_ERROR_MESSAGE =
  8 |   'Basis Theory Elements did not load properly. Check network tab for more details.';
  9 | 
 10 | const ELEMENTS_SCRIPT_UNKNOWN_ERROR_MESSAGE =
 11 |   'Unable to load the Elements script. This may be due to network restrictions or browser extensions like ad blockers interfering with script loading. Check browser settings or network connection and try again.';
 12 | 
 13 | const ELEMENTS_SCRIPT_FAILED_TO_DELIVER =
 14 |   'Failed to deliver Elements script from Basis Theory. Check your network connection and try again or contact support@basistheory.com';
 15 | 
 16 | const CARD_BRANDS = [
 17 |   'visa',
 18 |   'mastercard',
 19 |   'american-express',
 20 |   'discover',
 21 |   'diners-club',
 22 |   'jcb',
 23 |   'unionpay',
 24 |   'maestro',
 25 |   'elo',
 26 |   'hiper',
 27 |   'hipercard',
 28 |   'mir',
 29 |   'unknown',
 30 | ] as const;
 31 | 
 32 | const CARD_ICON_POSITIONS = ['left', 'right', 'none'] as const;
 33 | 
 34 | // https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/autocomplete
 35 | const AUTOCOMPLETE_VALUES = [
 36 |   'additional-name',
 37 |   'address-level1',
 38 |   'address-level2',
 39 |   'address-level3',
 40 |   'address-level4',
 41 |   'address-line1',
 42 |   'address-line2',
 43 |   'address-line3',
 44 |   'bday-day',
 45 |   'bday-month',
 46 |   'bday-year',
 47 |   'bday',
 48 |   'billing',
 49 |   'cc-additional-name',
 50 |   'cc-csc',
 51 |   'cc-exp-month',
 52 |   'cc-exp-year',
 53 |   'cc-exp',
 54 |   'cc-family-name',
 55 |   'cc-given-name',
 56 |   'cc-name',
 57 |   'cc-number',
 58 |   'cc-type',
 59 |   'country-name',
 60 |   'country',
 61 |   'current-password',
 62 |   'email',
 63 |   'family-name',
 64 |   'fax',
 65 |   'given-name',
 66 |   'home',
 67 |   'honorific-prefix',
 68 |   'honorific-suffix',
 69 |   'language',
 70 |   'mobile',
 71 |   'name',
 72 |   'new-password',
 73 |   'nickname',
 74 |   'off',
 75 |   'on',
 76 |   'one-time-code',
 77 |   'organization-title',
 78 |   'organization',
 79 |   'page',
 80 |   'postal-code',
 81 |   'sex',
 82 |   'shipping',
 83 |   'street-address',
 84 |   'tel-area-code',
 85 |   'tel-country-code',
 86 |   'tel-extension',
 87 |   'tel-local-prefix',
 88 |   'tel-local-suffix',
 89 |   'tel-local',
 90 |   'tel-national',
 91 |   'tel',
 92 |   'transaction-amount',
 93 |   'transaction-currency',
 94 |   'url',
 95 |   'username',
 96 |   'work',
 97 | ] as const;
 98 | 
 99 | export {
100 |   ELEMENTS_INIT_ERROR_MESSAGE,
101 |   ELEMENTS_NOM_DOM_ERROR_MESSAGE,
102 |   ELEMENTS_SCRIPT_LOAD_ERROR_MESSAGE,
103 |   ELEMENTS_SCRIPT_UNKNOWN_ERROR_MESSAGE,
104 |   ELEMENTS_SCRIPT_FAILED_TO_DELIVER,
105 |   CARD_BRANDS,
106 |   CARD_ICON_POSITIONS,
107 |   AUTOCOMPLETE_VALUES,
108 | };
109 | 


--------------------------------------------------------------------------------
/src/elements/index.ts:
--------------------------------------------------------------------------------
1 | export * from './services';
2 | export * from './script';
3 | export * from './load';
4 | 


--------------------------------------------------------------------------------
/src/elements/script.ts:
--------------------------------------------------------------------------------
 1 | const findScript = (url: string): HTMLScriptElement | null =>
 2 |   document.querySelector<HTMLScriptElement>(`script[src^="${url}"]`);
 3 | 
 4 | const injectScript = (url: string): HTMLScriptElement => {
 5 |   const script = document.createElement('script');
 6 | 
 7 |   script.src = url;
 8 | 
 9 |   const parent = document.head || document.body;
10 | 
11 |   if (!parent) {
12 |     throw new Error('No <head> or <body> elements found in document.');
13 |   }
14 | 
15 |   parent.append(script);
16 | 
17 |   return script;
18 | };
19 | 
20 | export { findScript, injectScript };
21 | 


--------------------------------------------------------------------------------
/src/elements/services/index.ts:
--------------------------------------------------------------------------------
1 | export * from './tokenize';
2 | export * from './tokens';
3 | export * from './proxy';
4 | export * from './token-intents';
5 | 


--------------------------------------------------------------------------------
/src/elements/services/proxy.ts:
--------------------------------------------------------------------------------
 1 | import { BasisTheoryProxy } from '@/proxy';
 2 | import type {
 3 |   Proxy as ElementsProxy,
 4 |   BasisTheoryElementsInternal,
 5 | } from '@/types/elements';
 6 | import type { Proxy, ProxyRequestOptions } from '@/types/sdk';
 7 | 
 8 | const delegateProxy = (
 9 |   elements?: BasisTheoryElementsInternal
10 | ): new (
11 |   ...args: ConstructorParameters<typeof BasisTheoryProxy>
12 | ) => ElementsProxy & Proxy =>
13 |   class BasisTheoryProxyElementsDelegate
14 |     extends BasisTheoryProxy
15 |     implements ElementsProxy {
16 |     public get(options?: ProxyRequestOptions): Promise<any> {
17 |       if (elements !== undefined) {
18 |         return elements.proxy.get(options);
19 |       }
20 | 
21 |       return super.get(options);
22 |     }
23 | 
24 |     public post(options?: ProxyRequestOptions): Promise<any> {
25 |       if (elements !== undefined) {
26 |         return elements.proxy.post(options);
27 |       }
28 | 
29 |       return super.post(options);
30 |     }
31 | 
32 |     public put(options?: ProxyRequestOptions): Promise<any> {
33 |       if (elements !== undefined) {
34 |         return elements.proxy.put(options);
35 |       }
36 | 
37 |       return super.put(options);
38 |     }
39 | 
40 |     public patch(options?: ProxyRequestOptions): Promise<any> {
41 |       if (elements !== undefined) {
42 |         return elements.proxy.patch(options);
43 |       }
44 | 
45 |       return super.patch(options);
46 |     }
47 | 
48 |     public delete(options?: ProxyRequestOptions): Promise<any> {
49 |       if (elements !== undefined) {
50 |         return elements.proxy.delete(options);
51 |       }
52 | 
53 |       return super.delete(options);
54 |     }
55 |   };
56 | 
57 | export { delegateProxy };
58 | 


--------------------------------------------------------------------------------
/src/elements/services/token-intents.ts:
--------------------------------------------------------------------------------
 1 | import { BasisTheoryTokenIntents } from '@/token-intents';
 2 | import type {
 3 |   TokenIntents as ElementsTokenIntents,
 4 |   BasisTheoryElementsInternal,
 5 |   CreateTokenIntent as ElementsCreateTokenIntent,
 6 | } from '@/types/elements';
 7 | import type { CreateTokenIntent, TokenIntent } from '@/types/models';
 8 | import type { RequestOptions, TokenIntents } from '@/types/sdk';
 9 | 
10 | const delegateTokenIntents = (
11 |   elements?: BasisTheoryElementsInternal
12 | ): new (
13 |   ...args: ConstructorParameters<typeof BasisTheoryTokenIntents>
14 | ) => ElementsTokenIntents & TokenIntents =>
15 |   class BasisTheoryTokenIntentsElementsDelegate
16 |     extends BasisTheoryTokenIntents
17 |     implements ElementsTokenIntents {
18 |     public create(
19 |       payload: CreateTokenIntent | ElementsCreateTokenIntent,
20 |       requestOptions?: RequestOptions
21 |     ): Promise<TokenIntent> {
22 |       if (elements?.hasElement(payload)) {
23 |         return elements.tokenIntents.create(
24 |           payload as ElementsCreateTokenIntent,
25 |           requestOptions
26 |         );
27 |       }
28 | 
29 |       return super.create(payload as CreateTokenIntent, requestOptions);
30 |     }
31 |   };
32 | 
33 | export { delegateTokenIntents };
34 | 


--------------------------------------------------------------------------------
/src/elements/services/tokenize.ts:
--------------------------------------------------------------------------------
 1 | import { BasisTheoryTokenize } from '@/tokenize';
 2 | import type {
 3 |   Tokenize as ElementsTokenize,
 4 |   BasisTheoryElementsInternal,
 5 |   TokenizeData as ElementsTokenizeData,
 6 | } from '@/types/elements';
 7 | import type { TokenizeData } from '@/types/models';
 8 | import type { RequestOptions, Tokenize } from '@/types/sdk';
 9 | 
10 | const delegateTokenize = (
11 |   elements?: BasisTheoryElementsInternal
12 | ): new (
13 |   ...args: ConstructorParameters<typeof BasisTheoryTokenize>
14 | ) => ElementsTokenize & Tokenize =>
15 |   class BasisTheoryTokenizesElementsDelegate
16 |     extends BasisTheoryTokenize
17 |     implements ElementsTokenize {
18 |     public tokenize(
19 |       payload: ElementsTokenizeData | TokenizeData,
20 |       requestOptions?: RequestOptions
21 |     ): Promise<TokenizeData> {
22 |       if (elements?.hasElement(payload)) {
23 |         return elements.tokenize(
24 |           payload as ElementsTokenizeData,
25 |           requestOptions
26 |         );
27 |       }
28 | 
29 |       return super.tokenize(payload as TokenizeData, requestOptions);
30 |     }
31 |   };
32 | 
33 | export { delegateTokenize };
34 | 


--------------------------------------------------------------------------------
/src/elements/services/tokens.ts:
--------------------------------------------------------------------------------
 1 | import { BasisTheoryTokens } from '@/tokens';
 2 | import type {
 3 |   Tokens as ElementsTokens,
 4 |   BasisTheoryElementsInternal,
 5 |   CreateToken as ElementsCreateToken,
 6 |   UpdateToken as ElementsUpdateToken,
 7 | } from '@/types/elements';
 8 | import type { CreateToken, Token, UpdateToken } from '@/types/models';
 9 | import type { RequestOptions, Tokens } from '@/types/sdk';
10 | 
11 | const delegateTokens = (
12 |   elements?: BasisTheoryElementsInternal
13 | ): new (
14 |   ...args: ConstructorParameters<typeof BasisTheoryTokens>
15 | ) => ElementsTokens & Tokens =>
16 |   class BasisTheoryTokensElementsDelegate
17 |     extends BasisTheoryTokens
18 |     implements ElementsTokens {
19 |     public create(
20 |       payload: CreateToken | ElementsCreateToken,
21 |       requestOptions?: RequestOptions
22 |     ): Promise<Token> {
23 |       if (elements?.hasElement(payload)) {
24 |         return elements.tokens.create(
25 |           payload as ElementsCreateToken,
26 |           requestOptions
27 |         );
28 |       }
29 | 
30 |       return super.create(payload as CreateToken, requestOptions);
31 |     }
32 | 
33 |     public update(
34 |       id: string,
35 |       payload: UpdateToken | ElementsUpdateToken,
36 |       requestOptions?: RequestOptions
37 |     ): Promise<Token> {
38 |       if (elements?.hasElement(payload)) {
39 |         return elements.tokens.update(
40 |           id,
41 |           payload as ElementsUpdateToken,
42 |           requestOptions
43 |         );
44 |       }
45 | 
46 |       return super.update(id, payload as UpdateToken, requestOptions);
47 |     }
48 | 
49 |     public retrieve(
50 |       id: string,
51 |       requestOptions?: RequestOptions
52 |       // avoid casting when accessing token data props
53 |       // eslint-disable-next-line @typescript-eslint/no-explicit-any
54 |     ): Promise<Token<any>> {
55 |       if (elements !== undefined) {
56 |         return elements.tokens.retrieve(id, requestOptions);
57 |       }
58 | 
59 |       return super.retrieve(id, requestOptions);
60 |     }
61 |   };
62 | 
63 | export { delegateTokens };
64 | 


--------------------------------------------------------------------------------
/src/index.ts:
--------------------------------------------------------------------------------
 1 | import type { BasisTheoryInit } from '@/types/sdk';
 2 | import { BasisTheory } from './BasisTheory';
 3 | 
 4 | /**
 5 |  * Default instance used to expose bundle in <script> tags. <br/>
 6 |  * Not meant to be used in Node environment.
 7 |  */
 8 | export const _instance: BasisTheoryInit = new BasisTheory();
 9 | 
10 | export * from './BasisTheory';
11 | export * from './applications';
12 | export * from './tokens';
13 | 


--------------------------------------------------------------------------------
/src/logs/BasisTheoryLogs.ts:
--------------------------------------------------------------------------------
 1 | import { BasisTheoryService } from '@/service';
 2 | import { CrudBuilder } from '@/service/CrudBuilder';
 3 | import type { Log } from '@/types/models';
 4 | import type { ListLogQuery } from '@/types/sdk';
 5 | 
 6 | export const BasisTheoryLogs = new CrudBuilder(
 7 |   class BasisTheoryLogs extends BasisTheoryService {}
 8 | )
 9 |   .list<Log, ListLogQuery>()
10 |   .build();
11 | 
12 | export type BasisTheoryLogs = InstanceType<typeof BasisTheoryLogs>;
13 | 


--------------------------------------------------------------------------------
/src/logs/index.ts:
--------------------------------------------------------------------------------
1 | export { BasisTheoryLogs } from './BasisTheoryLogs';
2 | 


--------------------------------------------------------------------------------
/src/permissions/BasisTheoryPermissions.ts:
--------------------------------------------------------------------------------
 1 | import { createRequestConfig, dataExtractor, getQueryParams } from '@/common';
 2 | import { BasisTheoryService } from '@/service';
 3 | import type { Permission } from '@/types/models';
 4 | import type { ListPermissionsQuery, RequestOptions } from '@/types/sdk';
 5 | 
 6 | export class BasisTheoryPermissions extends BasisTheoryService {
 7 |   public list(
 8 |     query?: ListPermissionsQuery,
 9 |     options?: RequestOptions
10 |   ): Promise<Permission[]> {
11 |     const url = `/${getQueryParams(query)}`;
12 | 
13 |     return this.client
14 |       .get(url, createRequestConfig(options))
15 |       .then(dataExtractor);
16 |   }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/permissions/index.ts:
--------------------------------------------------------------------------------
1 | export { BasisTheoryPermissions } from './BasisTheoryPermissions';
2 | 


--------------------------------------------------------------------------------
/src/proxies/BasisTheoryProxies.ts:
--------------------------------------------------------------------------------
 1 | import type { AxiosRequestTransformer, AxiosResponseTransformer } from 'axios';
 2 | import {
 3 |   transformProxyResponseCamelCase,
 4 |   transformProxyRequestSnakeCase,
 5 | } from '@/common/utils';
 6 | import { BasisTheoryService } from '@/service';
 7 | import type { BasisTheoryServiceOptions } from '@/service';
 8 | import { CrudBuilder } from '@/service/CrudBuilder';
 9 | import type {
10 |   CreateProxy,
11 |   UpdateProxy,
12 |   Proxy,
13 |   PatchProxy,
14 | } from '@/types/models';
15 | import type { ListProxyQuery } from '@/types/sdk';
16 | 
17 | export const BasisTheoryProxies = new CrudBuilder(
18 |   class BasisTheoryProxies extends BasisTheoryService {
19 |     public constructor(options: BasisTheoryServiceOptions) {
20 |       const _options = {
21 |         ...options,
22 |       };
23 | 
24 |       // eslint-disable-next-line unicorn/prefer-spread
25 |       _options.transformRequest = ([] as AxiosRequestTransformer[]).concat(
26 |         transformProxyRequestSnakeCase,
27 |         options.transformRequest || []
28 |       );
29 | 
30 |       // eslint-disable-next-line unicorn/prefer-spread
31 |       _options.transformResponse = ([] as AxiosResponseTransformer[]).concat(
32 |         transformProxyResponseCamelCase,
33 |         options.transformResponse || []
34 |       );
35 | 
36 |       super(_options);
37 |     }
38 |   }
39 | )
40 |   .create<Proxy, CreateProxy>()
41 |   .retrieve<Proxy>()
42 |   .update<Proxy, UpdateProxy>()
43 |   .patch<PatchProxy>()
44 |   .delete()
45 |   .list<Proxy, ListProxyQuery>()
46 |   .build();
47 | 


--------------------------------------------------------------------------------
/src/proxies/index.ts:
--------------------------------------------------------------------------------
1 | export * from './BasisTheoryProxies';
2 | 


--------------------------------------------------------------------------------
/src/proxy/BasisTheoryProxy.ts:
--------------------------------------------------------------------------------
 1 | import {
 2 |   createRequestConfig,
 3 |   dataAndHeadersExtractor,
 4 |   dataExtractor,
 5 |   proxyRaw,
 6 | } from '@/common';
 7 | import { BasisTheoryService } from '@/service';
 8 | import type { Proxy, ProxyRequestOptions } from '@/types/sdk';
 9 | 
10 | type PROXY_METHODS = 'get' | 'post' | 'put' | 'patch' | 'delete';
11 | 
12 | export class BasisTheoryProxy extends BasisTheoryService implements Proxy {
13 |   public get(options?: ProxyRequestOptions): Promise<any> {
14 |     return this.proxyRequest('get', options);
15 |   }
16 | 
17 |   public post(options?: ProxyRequestOptions): Promise<any> {
18 |     return this.proxyRequest('post', options);
19 |   }
20 | 
21 |   public put(options?: ProxyRequestOptions): Promise<any> {
22 |     return this.proxyRequest('put', options);
23 |   }
24 | 
25 |   public patch(options?: ProxyRequestOptions): Promise<any> {
26 |     return this.proxyRequest('patch', options);
27 |   }
28 | 
29 |   public delete(options?: ProxyRequestOptions): Promise<any> {
30 |     return this.proxyRequest('delete', options);
31 |   }
32 | 
33 |   private proxyRequest(
34 |     method: PROXY_METHODS,
35 |     options?: ProxyRequestOptions
36 |   ): Promise<any> {
37 |     if (method === 'post' || method === 'put' || method === 'patch') {
38 |       const extractor =
39 |         options?.includeResponseHeaders && method === 'post'
40 |           ? dataAndHeadersExtractor
41 |           : dataExtractor;
42 | 
43 |       return this.client[method](
44 |         options?.path ?? '',
45 |         options?.body ?? undefined,
46 |         createRequestConfig(options, {
47 |           transformRequest: proxyRaw,
48 |           transformResponse: proxyRaw,
49 |         })
50 |       ).then(extractor);
51 |     }
52 | 
53 |     return this.client[method](
54 |       options?.path ?? '/',
55 |       createRequestConfig(options, {
56 |         transformRequest: proxyRaw,
57 |         transformResponse: proxyRaw,
58 |       })
59 |     ).then(dataExtractor);
60 |   }
61 | }
62 | 


--------------------------------------------------------------------------------
/src/proxy/index.ts:
--------------------------------------------------------------------------------
1 | export * from './BasisTheoryProxy';
2 | 


--------------------------------------------------------------------------------
/src/reactor-formulas/BasisTheoryReactorFormulas.ts:
--------------------------------------------------------------------------------
 1 | import { BasisTheoryService } from '@/service';
 2 | import { CrudBuilder } from '@/service/CrudBuilder';
 3 | import type { CreateReactorFormula, ReactorFormula } from '@/types/models';
 4 | import type { ListReactorFormulaQuery } from '@/types/sdk';
 5 | 
 6 | export const BasisTheoryReactorFormulas = new CrudBuilder(
 7 |   class BasisTheoryReactorFormulas extends BasisTheoryService {}
 8 | )
 9 |   .create<ReactorFormula, CreateReactorFormula>()
10 |   .retrieve<ReactorFormula>()
11 |   .update<ReactorFormula, CreateReactorFormula>()
12 |   .delete()
13 |   .list<ReactorFormula, ListReactorFormulaQuery>()
14 |   .build();
15 | 
16 | export type BasisTheoryReactorFormulas = InstanceType<
17 |   typeof BasisTheoryReactorFormulas
18 | >;
19 | 


--------------------------------------------------------------------------------
/src/reactor-formulas/index.ts:
--------------------------------------------------------------------------------
1 | export { BasisTheoryReactorFormulas } from './BasisTheoryReactorFormulas';
2 | 


--------------------------------------------------------------------------------
/src/reactors/BasisTheoryReactors.ts:
--------------------------------------------------------------------------------
 1 | import type { AxiosRequestTransformer, AxiosResponseTransformer } from 'axios';
 2 | import { createRequestConfig, dataExtractor, proxyRaw } from '@/common';
 3 | import {
 4 |   transformReactorResponseCamelCase,
 5 |   transformReactorRequestSnakeCase,
 6 | } from '@/common/utils';
 7 | import { BasisTheoryService } from '@/service';
 8 | import type { BasisTheoryServiceOptions } from '@/service';
 9 | import { CrudBuilder } from '@/service/CrudBuilder';
10 | import type {
11 |   Reactor,
12 |   CreateReactor,
13 |   UpdateReactor,
14 |   ReactResponse,
15 |   PatchReactor,
16 | } from '@/types/models';
17 | import type {
18 |   ListReactorQuery,
19 |   ReactRequest,
20 |   RequestOptions,
21 | } from '@/types/sdk';
22 | 
23 | export const BasisTheoryReactors = new CrudBuilder(
24 |   class BasisTheoryReactors extends BasisTheoryService {
25 |     public constructor(options: BasisTheoryServiceOptions) {
26 |       const _options = {
27 |         ...options,
28 |       };
29 | 
30 |       // eslint-disable-next-line unicorn/prefer-spread
31 |       _options.transformRequest = ([] as AxiosRequestTransformer[]).concat(
32 |         transformReactorRequestSnakeCase,
33 |         options.transformRequest || []
34 |       );
35 | 
36 |       // eslint-disable-next-line unicorn/prefer-spread
37 |       _options.transformResponse = ([] as AxiosResponseTransformer[]).concat(
38 |         transformReactorResponseCamelCase,
39 |         options.transformResponse || []
40 |       );
41 | 
42 |       super(_options);
43 |     }
44 | 
45 |     public react(
46 |       reactorId: string,
47 |       request: ReactRequest,
48 |       options?: RequestOptions
49 |     ): Promise<ReactResponse> {
50 |       return this.client
51 |         .post(
52 |           `/${reactorId}/react`,
53 |           request,
54 |           createRequestConfig(options, {
55 |             transformRequest: proxyRaw,
56 |             transformResponse: proxyRaw,
57 |           })
58 |         )
59 |         .then(dataExtractor);
60 |     }
61 |   }
62 | )
63 |   .create<Reactor, CreateReactor>()
64 |   .retrieve<Reactor>()
65 |   .update<Reactor, UpdateReactor>()
66 |   .patch<PatchReactor>()
67 |   .delete()
68 |   .list<Reactor, ListReactorQuery>()
69 |   .build();
70 | 
71 | export type BasisTheoryReactors = InstanceType<typeof BasisTheoryReactors>;
72 | 


--------------------------------------------------------------------------------
/src/reactors/index.ts:
--------------------------------------------------------------------------------
1 | export { BasisTheoryReactors } from './BasisTheoryReactors';
2 | 


--------------------------------------------------------------------------------
/src/service/BasisTheoryService.ts:
--------------------------------------------------------------------------------
 1 | import axios from 'axios';
 2 | import type {
 3 |   AxiosInstance,
 4 |   AxiosRequestTransformer,
 5 |   AxiosResponseTransformer,
 6 | } from 'axios';
 7 | import {
 8 |   API_KEY_HEADER,
 9 |   CLIENT_USER_AGENT_HEADER,
10 |   USER_AGENT_HEADER,
11 |   errorInterceptor,
12 |   transformRequestSnakeCase,
13 |   transformResponseCamelCase,
14 |   buildUserAgentString,
15 |   buildClientUserAgentString,
16 |   debugTransform,
17 |   errorInterceptorDebug,
18 | } from '@/common';
19 | import { BasisTheoryServiceOptions } from './types';
20 | 
21 | export abstract class BasisTheoryService<
22 |   T extends BasisTheoryServiceOptions = BasisTheoryServiceOptions
23 | > {
24 |   public readonly client: AxiosInstance;
25 | 
26 |   public constructor(options: T) {
27 |     const {
28 |       apiKey,
29 |       baseURL,
30 |       transformRequest,
31 |       transformResponse,
32 |       appInfo,
33 |       debug,
34 |     } = options;
35 | 
36 |     if (typeof axios === 'string') {
37 |       // known issue with create react app
38 |       // eslint-disable-next-line unicorn/prefer-type-error
39 |       throw new Error(
40 |         'basis-theory-js@1.77.0+ and basis-theory-react@1.12.1+ are not supported with CRA 5, go to https://github.com/Basis-Theory/basis-theory-js/issues/365#issuecomment-1662883062 for workarounds.'
41 |       );
42 |     } else {
43 |       this.client = axios.create({
44 |         baseURL,
45 |         headers: {
46 |           [API_KEY_HEADER]: apiKey,
47 |           [CLIENT_USER_AGENT_HEADER]: buildClientUserAgentString(appInfo),
48 |           ...(typeof window === 'undefined' && {
49 |             [USER_AGENT_HEADER]: buildUserAgentString(appInfo),
50 |           }),
51 |         },
52 |         /* eslint-disable unicorn/prefer-spread */
53 |         transformRequest: ([] as AxiosRequestTransformer[]).concat(
54 |           transformRequest || transformRequestSnakeCase,
55 |           axios.defaults.transformRequest as AxiosRequestTransformer[]
56 |         ),
57 |         transformResponse: (axios.defaults
58 |           .transformResponse as AxiosResponseTransformer[]).concat(
59 |           transformResponse || transformResponseCamelCase,
60 |           debug ? debugTransform : []
61 |         ),
62 |         /* eslint-enable unicorn/prefer-spread */
63 |       });
64 |       this.client.interceptors.response.use(
65 |         undefined,
66 |         debug ? errorInterceptorDebug : errorInterceptor
67 |       );
68 |     }
69 |   }
70 | }
71 | 


--------------------------------------------------------------------------------
/src/service/CrudBuilder.ts:
--------------------------------------------------------------------------------
  1 | /* eslint-disable max-classes-per-file, @typescript-eslint/no-shadow */
  2 | import {
  3 |   CONTENT_TYPE_HEADER,
  4 |   createRequestConfig,
  5 |   dataExtractor,
  6 |   getQueryParams,
  7 |   MERGE_CONTENT_TYPE,
  8 | } from '@/common';
  9 | import type {
 10 |   PaginatedList,
 11 |   PaginatedQuery,
 12 |   RequestOptions,
 13 |   Create as ICreate,
 14 |   Retrieve as IRetrieve,
 15 |   Update as IUpdate,
 16 |   Delete as IDelete,
 17 |   List as IList,
 18 |   Patch as IPatch,
 19 | } from '@/types/sdk';
 20 | import { BasisTheoryService } from './BasisTheoryService';
 21 | 
 22 | /* eslint-disable @typescript-eslint/no-explicit-any */
 23 | type BasisTheoryServiceConstructor<
 24 |   T extends BasisTheoryService = BasisTheoryService
 25 | > = new (...params: any[]) => T;
 26 | 
 27 | type ICreateConstructor<T, C> = new (...args: any[]) => ICreate<T, C>;
 28 | type IRetrieveConstructor<T> = new (...args: any[]) => IRetrieve<T>;
 29 | type IUpdateConstructor<T, U> = new (...args: any[]) => IUpdate<T, U>;
 30 | type IPatchConstructor<P> = new (...args: any[]) => IPatch<P>;
 31 | type IDeleteConstructor = new (...args: any[]) => IDelete;
 32 | type IListConstructor<T, Q extends PaginatedQuery> = new (
 33 |   ...args: any[]
 34 | ) => IList<T, Q>;
 35 | /* eslint-enable @typescript-eslint/no-explicit-any */
 36 | 
 37 | const Create = <T, C, S extends BasisTheoryServiceConstructor>(Service: S): S =>
 38 |   class Create extends Service implements ICreate<T, C> {
 39 |     public create(model: C, options?: RequestOptions): Promise<T> {
 40 |       return this.client
 41 |         .post('/', model, createRequestConfig(options))
 42 |         .then(dataExtractor);
 43 |     }
 44 |   };
 45 | 
 46 | const Retrieve = <T, S extends BasisTheoryServiceConstructor>(Service: S): S =>
 47 |   class Retrieve extends Service implements IRetrieve<T> {
 48 |     public retrieve(id: string, options?: RequestOptions): Promise<T> {
 49 |       return this.client
 50 |         .get(id, createRequestConfig(options))
 51 |         .then(dataExtractor);
 52 |     }
 53 |   };
 54 | 
 55 | const Update = <T, U, S extends BasisTheoryServiceConstructor>(Service: S): S =>
 56 |   class Update extends Service implements IUpdate<T, U> {
 57 |     public update(id: string, model: U, options?: RequestOptions): Promise<T> {
 58 |       return this.client
 59 |         .put(id, model, createRequestConfig(options))
 60 |         .then(dataExtractor);
 61 |     }
 62 |   };
 63 | 
 64 | const Patch = <P, S extends BasisTheoryServiceConstructor>(Service: S): S =>
 65 |   class Patch extends Service implements IPatch<P> {
 66 |     public patch(
 67 |       id: string,
 68 |       model: P,
 69 |       options?: RequestOptions
 70 |     ): Promise<void> {
 71 |       const config = createRequestConfig(options);
 72 | 
 73 |       return this.client
 74 |         .patch(id, model, {
 75 |           ...config,
 76 |           headers: {
 77 |             ...(config?.headers || {}),
 78 |             [CONTENT_TYPE_HEADER]: MERGE_CONTENT_TYPE,
 79 |           },
 80 |         })
 81 |         .then(dataExtractor);
 82 |     }
 83 |   };
 84 | 
 85 | const Delete = <S extends BasisTheoryServiceConstructor>(Service: S): S =>
 86 |   class Delete extends Service implements IDelete {
 87 |     public async delete(id: string, options?: RequestOptions): Promise<void> {
 88 |       await this.client.delete(id, createRequestConfig(options));
 89 |     }
 90 |   };
 91 | 
 92 | const List = <
 93 |   T,
 94 |   Q extends PaginatedQuery,
 95 |   S extends BasisTheoryServiceConstructor
 96 | >(
 97 |   Service: S
 98 | ): S =>
 99 |   class List extends Service implements IList<T, Q> {
100 |     public list(
101 |       query: Q = {} as Q,
102 |       options: RequestOptions = {} as RequestOptions
103 |     ): Promise<PaginatedList<T>> {
104 |       const url = `/${getQueryParams(query)}`;
105 | 
106 |       return this.client
107 |         .get(url, createRequestConfig(options))
108 |         .then(dataExtractor);
109 |     }
110 |   };
111 | 
112 | class CrudBuilder<Class extends BasisTheoryServiceConstructor> {
113 |   private BaseService: Class;
114 | 
115 |   public constructor(baseService: Class) {
116 |     this.BaseService = baseService;
117 |   }
118 | 
119 |   public create<T, C>(): CrudBuilder<Class & ICreateConstructor<T, C>> {
120 |     // eslint-disable-next-line new-cap
121 |     this.BaseService = Create<T, C, Class>(this.BaseService);
122 | 
123 |     return (this as unknown) as CrudBuilder<Class & ICreateConstructor<T, C>>;
124 |   }
125 | 
126 |   public retrieve<T>(): CrudBuilder<Class & IRetrieveConstructor<T>> {
127 |     // eslint-disable-next-line new-cap
128 |     this.BaseService = Retrieve<T, Class>(this.BaseService);
129 | 
130 |     return (this as unknown) as CrudBuilder<Class & IRetrieveConstructor<T>>;
131 |   }
132 | 
133 |   public update<T, U>(): CrudBuilder<Class & IUpdateConstructor<T, U>> {
134 |     // eslint-disable-next-line new-cap
135 |     this.BaseService = Update<T, U, Class>(this.BaseService);
136 | 
137 |     return (this as unknown) as CrudBuilder<Class & IUpdateConstructor<T, U>>;
138 |   }
139 | 
140 |   public patch<P>(): CrudBuilder<Class & IPatchConstructor<P>> {
141 |     // eslint-disable-next-line new-cap
142 |     this.BaseService = Patch<P, Class>(this.BaseService);
143 | 
144 |     return (this as unknown) as CrudBuilder<Class & IPatchConstructor<P>>;
145 |   }
146 | 
147 |   public delete(): CrudBuilder<Class & IDeleteConstructor> {
148 |     // eslint-disable-next-line new-cap
149 |     this.BaseService = Delete<Class>(this.BaseService);
150 | 
151 |     return (this as unknown) as CrudBuilder<Class & IDeleteConstructor>;
152 |   }
153 | 
154 |   public list<T, Q extends PaginatedQuery>(): CrudBuilder<
155 |     Class & IListConstructor<T, Q>
156 |   > {
157 |     // eslint-disable-next-line new-cap
158 |     this.BaseService = List<T, Q, Class>(this.BaseService);
159 | 
160 |     return (this as unknown) as CrudBuilder<Class & IListConstructor<T, Q>>;
161 |   }
162 | 
163 |   public build(): Class {
164 |     return this.BaseService;
165 |   }
166 | }
167 | 
168 | export { CrudBuilder };
169 | export type {
170 |   ICreate,
171 |   IRetrieve,
172 |   IUpdate,
173 |   IPatch,
174 |   IDelete,
175 |   IList,
176 |   BasisTheoryServiceConstructor,
177 | };
178 | 
179 | /* eslint-enable max-classes-per-file, @typescript-eslint/no-shadow */
180 | 


--------------------------------------------------------------------------------
/src/service/index.ts:
--------------------------------------------------------------------------------
1 | export * from './types';
2 | export * from './BasisTheoryService';
3 | 


--------------------------------------------------------------------------------
/src/service/types.ts:
--------------------------------------------------------------------------------
 1 | import type { AxiosRequestConfig } from 'axios';
 2 | import type { ApplicationInfo } from '@/types/sdk';
 3 | 
 4 | interface BasisTheoryServiceOptions
 5 |   extends Pick<AxiosRequestConfig, 'transformRequest' | 'transformResponse'> {
 6 |   apiKey: string;
 7 |   baseURL: string;
 8 |   debug?: boolean;
 9 |   appInfo?: ApplicationInfo;
10 | }
11 | 
12 | type RequestTransformers = Pick<
13 |   AxiosRequestConfig,
14 |   'transformRequest' | 'transformResponse'
15 | >;
16 | 
17 | export type { BasisTheoryServiceOptions, RequestTransformers };
18 | 


--------------------------------------------------------------------------------
/src/sessions/BasisTheorySessions.ts:
--------------------------------------------------------------------------------
 1 | import type { AxiosRequestTransformer, AxiosResponseTransformer } from 'axios';
 2 | import { createRequestConfig } from '@/common';
 3 | import {
 4 |   dataExtractor,
 5 |   transformProxyResponseCamelCase,
 6 |   transformProxyRequestSnakeCase,
 7 | } from '@/common/utils';
 8 | import { BasisTheoryService } from '@/service';
 9 | import type { BasisTheoryServiceOptions } from '@/service';
10 | import type { RequestOptions } from '@/types/sdk';
11 | import type {
12 |   CreateSessionResponse,
13 |   AuthorizeSessionRequest,
14 |   Sessions,
15 | } from '@/types/sdk/services/sessions';
16 | 
17 | export class BasisTheorySessions
18 |   extends BasisTheoryService
19 |   implements Sessions {
20 |   public constructor(options: BasisTheoryServiceOptions) {
21 |     const _options = {
22 |       ...options,
23 |     };
24 | 
25 |     // eslint-disable-next-line unicorn/prefer-spread
26 |     _options.transformRequest = ([] as AxiosRequestTransformer[]).concat(
27 |       transformProxyRequestSnakeCase,
28 |       options.transformRequest || []
29 |     );
30 | 
31 |     // eslint-disable-next-line unicorn/prefer-spread
32 |     _options.transformResponse = ([] as AxiosResponseTransformer[]).concat(
33 |       transformProxyResponseCamelCase,
34 |       options.transformResponse || []
35 |     );
36 | 
37 |     super(_options);
38 |   }
39 | 
40 |   public create(options: RequestOptions = {}): Promise<CreateSessionResponse> {
41 |     return this.client
42 |       .post('/', undefined, createRequestConfig(options))
43 |       .then(dataExtractor);
44 |   }
45 | 
46 |   public authorize(
47 |     authorizeSessionRequest: AuthorizeSessionRequest,
48 |     options: RequestOptions = {}
49 |   ): Promise<void> {
50 |     const url = `/authorize`;
51 | 
52 |     return this.client
53 |       .post(url, authorizeSessionRequest, createRequestConfig(options))
54 |       .then(dataExtractor);
55 |   }
56 | }
57 | 


--------------------------------------------------------------------------------
/src/sessions/index.ts:
--------------------------------------------------------------------------------
1 | export { BasisTheorySessions } from './BasisTheorySessions';
2 | 


--------------------------------------------------------------------------------
/src/tenants/BasisTheoryTenants.ts:
--------------------------------------------------------------------------------
  1 | import { createRequestConfig, dataExtractor, getQueryParams } from '@/common';
  2 | import { BasisTheoryService } from '@/service';
  3 | import { CrudBuilder } from '@/service/CrudBuilder';
  4 | import type {
  5 |   Tenant,
  6 |   TenantUsageReport,
  7 |   UpdateTenant,
  8 |   CreateTenantInvitation,
  9 |   TenantInvitation,
 10 |   TenantMember,
 11 | } from '@/types/models';
 12 | import type { RequestOptions } from '@/types/sdk/services';
 13 | import type { PaginatedList } from '@/types/sdk/services/shared';
 14 | import type {
 15 |   ListTenantInvitationsQuery,
 16 |   ListTenantMembersQuery,
 17 | } from '@/types/sdk/services/tenants';
 18 | 
 19 | export const BasisTheoryTenants = new CrudBuilder(
 20 |   class BasisTheoryTenants extends BasisTheoryService {
 21 |     public retrieve(options?: RequestOptions): Promise<Tenant> {
 22 |       return this.client
 23 |         .get('/', createRequestConfig(options))
 24 |         .then(dataExtractor);
 25 |     }
 26 | 
 27 |     public update(
 28 |       model: UpdateTenant,
 29 |       options?: RequestOptions
 30 |     ): Promise<Tenant> {
 31 |       return this.client
 32 |         .put('/', model, createRequestConfig(options))
 33 |         .then(dataExtractor);
 34 |     }
 35 | 
 36 |     public async delete(options?: RequestOptions): Promise<void> {
 37 |       await this.client.delete('/', createRequestConfig(options));
 38 |     }
 39 | 
 40 |     public retrieveUsageReport(
 41 |       options?: RequestOptions
 42 |     ): Promise<TenantUsageReport> {
 43 |       return this.client
 44 |         .get('/reports/usage', createRequestConfig(options))
 45 |         .then(dataExtractor);
 46 |     }
 47 | 
 48 |     public createInvitation(
 49 |       model: CreateTenantInvitation,
 50 |       options?: RequestOptions
 51 |     ): Promise<TenantInvitation> {
 52 |       return this.client
 53 |         .post('/invitations', model, createRequestConfig(options))
 54 |         .then(dataExtractor);
 55 |     }
 56 | 
 57 |     public resendInvitation(
 58 |       invitationId: string,
 59 |       options?: RequestOptions
 60 |     ): Promise<TenantInvitation> {
 61 |       return this.client
 62 |         .post(
 63 |           `/invitations/${invitationId}/resend`,
 64 |           {},
 65 |           createRequestConfig(options)
 66 |         )
 67 |         .then(dataExtractor);
 68 |     }
 69 | 
 70 |     public listInvitations(
 71 |       query?: ListTenantInvitationsQuery,
 72 |       options?: RequestOptions
 73 |     ): Promise<PaginatedList<TenantInvitation>> {
 74 |       const url = `/invitations${getQueryParams(query)}`;
 75 | 
 76 |       return this.client
 77 |         .get(url, createRequestConfig(options))
 78 |         .then(dataExtractor);
 79 |     }
 80 | 
 81 |     public retrieveInvitation(
 82 |       invitationId: string,
 83 |       options?: RequestOptions
 84 |     ): Promise<TenantInvitation> {
 85 |       return this.client
 86 |         .get(`/invitations/${invitationId}`, createRequestConfig(options))
 87 |         .then(dataExtractor);
 88 |     }
 89 | 
 90 |     public async deleteInvitation(
 91 |       invitationId: string,
 92 |       options?: RequestOptions
 93 |     ): Promise<void> {
 94 |       await this.client.delete(
 95 |         `/invitations/${invitationId}`,
 96 |         createRequestConfig(options)
 97 |       );
 98 |     }
 99 | 
100 |     public listMembers(
101 |       query?: ListTenantMembersQuery,
102 |       options?: RequestOptions
103 |     ): Promise<PaginatedList<TenantMember>> {
104 |       const url = `/members${getQueryParams(query)}`;
105 | 
106 |       return this.client
107 |         .get(url, createRequestConfig(options))
108 |         .then(dataExtractor);
109 |     }
110 | 
111 |     public async deleteMember(
112 |       memberId: string,
113 |       options?: RequestOptions
114 |     ): Promise<void> {
115 |       await this.client.delete(
116 |         `/members/${memberId}`,
117 |         createRequestConfig(options)
118 |       );
119 |     }
120 |   }
121 | ).build();
122 | 
123 | export type BasisTheoryTenants = InstanceType<typeof BasisTheoryTenants>;
124 | 


--------------------------------------------------------------------------------
/src/tenants/index.ts:
--------------------------------------------------------------------------------
1 | export { BasisTheoryTenants } from './BasisTheoryTenants';
2 | 


--------------------------------------------------------------------------------
/src/threeds/BasisTheoryThreeDs.ts:
--------------------------------------------------------------------------------
 1 | import { dataExtractor } from '@/common';
 2 | import { BasisTheoryService } from '@/service';
 3 | import {
 4 |   AuthenticateThreeDSSessionRequest,
 5 |   CreateThreeDSSessionRequest,
 6 |   CreateThreeDSSessionResponse,
 7 |   ThreeDSAuthentication,
 8 |   ThreeDSSession,
 9 | } from '@/types/models/threeds';
10 | import { ThreeDS } from '@/types/sdk/services/threeds';
11 | 
12 | export class BasisTheoryThreeDS extends BasisTheoryService implements ThreeDS {
13 |   public createSession(
14 |     createRequest: CreateThreeDSSessionRequest
15 |   ): Promise<CreateThreeDSSessionResponse> {
16 |     return this.client.post('/sessions', createRequest).then(dataExtractor);
17 |   }
18 | 
19 |   public getSessionById(sessionId: string): Promise<ThreeDSSession> {
20 |     return this.client.get(`/sessions/${sessionId}`).then(dataExtractor);
21 |   }
22 | 
23 |   public authenticateSession(
24 |     sessionId: string,
25 |     authenticateRequest: AuthenticateThreeDSSessionRequest
26 |   ): Promise<ThreeDSAuthentication> {
27 |     return this.client
28 |       .post(`/sessions/${sessionId}/authenticate`, authenticateRequest)
29 |       .then(dataExtractor);
30 |   }
31 | 
32 |   public getChallengeResult(sessionId: string): Promise<ThreeDSAuthentication> {
33 |     return this.client
34 |       .get(`/sessions/${sessionId}/challenge-result`)
35 |       .then(dataExtractor);
36 |   }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/threeds/index.ts:
--------------------------------------------------------------------------------
1 | export * from './BasisTheoryThreeDs';
2 | 


--------------------------------------------------------------------------------
/src/token-intents/BasisTheoryTokenIntents.ts:
--------------------------------------------------------------------------------
 1 | import type { AxiosRequestTransformer, AxiosResponseTransformer } from 'axios';
 2 | import {
 3 |   transformTokenRequestSnakeCase,
 4 |   transformTokenResponseCamelCase,
 5 | } from '@/common';
 6 | import { BasisTheoryService, BasisTheoryServiceOptions } from '@/service';
 7 | import { CrudBuilder } from '@/service/CrudBuilder';
 8 | import type { TokenIntent, CreateTokenIntent } from '@/types/models';
 9 | 
10 | export const BasisTheoryTokenIntents = new CrudBuilder(
11 |   class BasisTheoryTokenIntents extends BasisTheoryService {
12 |     public constructor(options: BasisTheoryServiceOptions) {
13 |       const _options = options;
14 | 
15 |       // eslint-disable-next-line unicorn/prefer-spread
16 |       _options.transformRequest = ([] as AxiosRequestTransformer[]).concat(
17 |         transformTokenRequestSnakeCase,
18 |         options.transformRequest || []
19 |       );
20 | 
21 |       // eslint-disable-next-line unicorn/prefer-spread
22 |       _options.transformResponse = ([] as AxiosResponseTransformer[]).concat(
23 |         transformTokenResponseCamelCase,
24 |         options.transformResponse || []
25 |       );
26 | 
27 |       super(_options);
28 |     }
29 |   }
30 | )
31 |   .create<TokenIntent, CreateTokenIntent>()
32 |   .delete()
33 |   .build();
34 | 
35 | export type BasisTheoryTokenIntents = InstanceType<
36 |   typeof BasisTheoryTokenIntents
37 | >;
38 | 


--------------------------------------------------------------------------------
/src/token-intents/index.ts:
--------------------------------------------------------------------------------
1 | export { BasisTheoryTokenIntents } from './BasisTheoryTokenIntents';
2 | 


--------------------------------------------------------------------------------
/src/tokenize/BasisTheoryTokenize.ts:
--------------------------------------------------------------------------------
 1 | import { createRequestConfig, dataExtractor, proxyRaw } from '@/common';
 2 | import { BasisTheoryService } from '@/service';
 3 | import type { TokenizeData } from '@/types/models';
 4 | import type { RequestOptions } from '@/types/sdk';
 5 | 
 6 | export class BasisTheoryTokenize extends BasisTheoryService {
 7 |   public tokenize(
 8 |     tokens: TokenizeData,
 9 |     options: RequestOptions = {}
10 |   ): Promise<TokenizeData> {
11 |     return this.client
12 |       .post(
13 |         '/',
14 |         tokens,
15 |         createRequestConfig(options, {
16 |           transformRequest: proxyRaw,
17 |           transformResponse: proxyRaw,
18 |         })
19 |       )
20 |       .then(dataExtractor);
21 |   }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/tokenize/index.ts:
--------------------------------------------------------------------------------
1 | export { BasisTheoryTokenize } from './BasisTheoryTokenize';
2 | 


--------------------------------------------------------------------------------
/src/tokens/BasisTheoryTokens.ts:
--------------------------------------------------------------------------------
 1 | import type { AxiosRequestTransformer, AxiosResponseTransformer } from 'axios';
 2 | import {
 3 |   CONTENT_TYPE_HEADER,
 4 |   createRequestConfig,
 5 |   MERGE_CONTENT_TYPE,
 6 | } from '@/common';
 7 | import {
 8 |   dataExtractor,
 9 |   transformTokenResponseCamelCase,
10 |   transformTokenRequestSnakeCase,
11 | } from '@/common/utils';
12 | import { BasisTheoryService, BasisTheoryServiceOptions } from '@/service';
13 | import { CrudBuilder } from '@/service/CrudBuilder';
14 | import type { Token, CreateToken, UpdateToken } from '@/types/models';
15 | import type {
16 |   PaginatedList,
17 |   RequestOptions,
18 |   ListTokensQuery,
19 |   SearchTokensRequest,
20 | } from '@/types/sdk';
21 | 
22 | export const BasisTheoryTokens = new CrudBuilder(
23 |   class BasisTheoryTokens extends BasisTheoryService {
24 |     public constructor(options: BasisTheoryServiceOptions) {
25 |       const _options = options;
26 | 
27 |       // eslint-disable-next-line unicorn/prefer-spread
28 |       _options.transformRequest = ([] as AxiosRequestTransformer[]).concat(
29 |         transformTokenRequestSnakeCase,
30 |         options.transformRequest || []
31 |       );
32 | 
33 |       // eslint-disable-next-line unicorn/prefer-spread
34 |       _options.transformResponse = ([] as AxiosResponseTransformer[]).concat(
35 |         transformTokenResponseCamelCase,
36 |         options.transformResponse || []
37 |       );
38 | 
39 |       super(_options);
40 |     }
41 | 
42 |     public retrieve(
43 |       id: string,
44 |       options: RequestOptions = {}
45 |       // avoid casting when accessing token data props
46 |       // eslint-disable-next-line @typescript-eslint/no-explicit-any
47 |     ): Promise<Token<any>> {
48 |       const url = `/${id}`;
49 | 
50 |       return this.client
51 |         .get(url, createRequestConfig(options))
52 |         .then(dataExtractor);
53 |     }
54 | 
55 |     public update(
56 |       id: string,
57 |       model: UpdateToken,
58 |       options: RequestOptions = {}
59 |     ): Promise<Token> {
60 |       const url = `/${id}`;
61 | 
62 |       const config = createRequestConfig(options);
63 | 
64 |       return this.client
65 |         .patch(url, model, {
66 |           ...config,
67 |           headers: {
68 |             ...(config?.headers || {}),
69 |             [CONTENT_TYPE_HEADER]: MERGE_CONTENT_TYPE,
70 |           },
71 |         })
72 |         .then(dataExtractor);
73 |     }
74 | 
75 |     public search(
76 |       searchRequest: SearchTokensRequest,
77 |       options?: RequestOptions
78 |     ): Promise<PaginatedList<Token>> {
79 |       return this.client
80 |         .post('/search', searchRequest, createRequestConfig(options))
81 |         .then(dataExtractor);
82 |     }
83 |   }
84 | )
85 |   .create<Token, CreateToken>()
86 |   .delete()
87 |   .list<Token, ListTokensQuery>()
88 |   .build();
89 | 
90 | export type BasisTheoryTokens = InstanceType<typeof BasisTheoryTokens>;
91 | 


--------------------------------------------------------------------------------
/src/tokens/index.ts:
--------------------------------------------------------------------------------
1 | export { BasisTheoryTokens } from './BasisTheoryTokens';
2 | 


--------------------------------------------------------------------------------
/src/types/elements/cardTypes.ts:
--------------------------------------------------------------------------------
  1 | type CardBrandId =
  2 |   | 'american-express'
  3 |   | 'diners-club'
  4 |   | 'discover'
  5 |   | 'elo'
  6 |   | 'hiper'
  7 |   | 'hipercard'
  8 |   | 'jcb'
  9 |   | 'maestro'
 10 |   | 'mastercard'
 11 |   | 'mir'
 12 |   | 'unionpay'
 13 |   | 'visa';
 14 | 
 15 | type CardBrandNiceType =
 16 |   | 'American Express'
 17 |   | 'Diners Club'
 18 |   | 'Discover'
 19 |   | 'Elo'
 20 |   | 'Hiper'
 21 |   | 'Hipercard'
 22 |   | 'JCB'
 23 |   | 'Maestro'
 24 |   | 'Mastercard'
 25 |   | 'Mir'
 26 |   | 'UnionPay'
 27 |   | 'Visa';
 28 | 
 29 | type SecurityCodeLabel = 'CVV' | 'CVC' | 'CID' | 'CVN' | 'CVE' | 'CVP2';
 30 | 
 31 | type CreditCardType = {
 32 |   code: {
 33 |     size: number;
 34 |     name: SecurityCodeLabel | string;
 35 |   };
 36 |   gaps: number[];
 37 |   lengths: number[];
 38 |   niceType: CardBrandNiceType | string;
 39 |   patterns: (number | [number, number])[];
 40 |   type: CardBrandId | string;
 41 | };
 42 | const VISA: CreditCardType = {
 43 |   niceType: 'Visa',
 44 |   type: 'visa',
 45 |   patterns: [4],
 46 |   gaps: [4, 8, 12],
 47 |   lengths: [16, 18, 19],
 48 |   code: {
 49 |     name: 'CVV',
 50 |     size: 3,
 51 |   },
 52 | };
 53 | 
 54 | const MASTERCARD: CreditCardType = {
 55 |   niceType: 'Mastercard',
 56 |   type: 'mastercard',
 57 |   patterns: [[51, 55], [2221, 2229], [223, 229], [23, 26], [270, 271], 2720],
 58 |   gaps: [4, 8, 12],
 59 |   lengths: [16],
 60 |   code: {
 61 |     name: 'CVC',
 62 |     size: 3,
 63 |   },
 64 | };
 65 | 
 66 | const AMERICAN_EXPRESS: CreditCardType = {
 67 |   niceType: 'American Express',
 68 |   type: 'american-express',
 69 |   patterns: [34, 37],
 70 |   gaps: [4, 10],
 71 |   lengths: [15],
 72 |   code: {
 73 |     name: 'CID',
 74 |     size: 4,
 75 |   },
 76 | };
 77 | 
 78 | const DINERS_CLUB: CreditCardType = {
 79 |   niceType: 'Diners Club',
 80 |   type: 'diners-club',
 81 |   patterns: [[300, 305], 36, 38, 39],
 82 |   gaps: [4, 10],
 83 |   lengths: [14, 16, 19],
 84 |   code: {
 85 |     name: 'CVV',
 86 |     size: 3,
 87 |   },
 88 | };
 89 | 
 90 | const DISCOVER: CreditCardType = {
 91 |   niceType: 'Discover',
 92 |   type: 'discover',
 93 |   patterns: [6011, [644, 649], 65],
 94 |   gaps: [4, 8, 12],
 95 |   lengths: [16, 19],
 96 |   code: {
 97 |     name: 'CID',
 98 |     size: 3,
 99 |   },
100 | };
101 | 
102 | const JCB: CreditCardType = {
103 |   niceType: 'JCB',
104 |   type: 'jcb',
105 |   patterns: [2131, 1800, [3528, 3589]],
106 |   gaps: [4, 8, 12],
107 |   lengths: [16, 17, 18, 19],
108 |   code: {
109 |     name: 'CVV',
110 |     size: 3,
111 |   },
112 | };
113 | 
114 | const UNION_PAY: CreditCardType = {
115 |   niceType: 'UnionPay',
116 |   type: 'unionpay',
117 |   patterns: [
118 |     620,
119 |     [62100, 62182],
120 |     [62184, 62187],
121 |     [62185, 62197],
122 |     [62200, 62205],
123 |     [622010, 622999],
124 |     622018,
125 |     [62207, 62209],
126 |     [623, 626],
127 |     6270,
128 |     6272,
129 |     6276,
130 |     [627700, 627779],
131 |     [627781, 627799],
132 |     [6282, 6289],
133 |     6291,
134 |     6292,
135 |     810,
136 |     [8110, 8131],
137 |     [8132, 8151],
138 |     [8152, 8163],
139 |     [8164, 8171],
140 |   ],
141 |   gaps: [4, 8, 12],
142 |   lengths: [14, 15, 16, 17, 18, 19],
143 |   code: {
144 |     name: 'CVN',
145 |     size: 3,
146 |   },
147 | };
148 | 
149 | const MAESTRO: CreditCardType = {
150 |   niceType: 'Maestro',
151 |   type: 'maestro',
152 |   patterns: [
153 |     493698,
154 |     [500000, 504174],
155 |     [504176, 506698],
156 |     [506779, 508999],
157 |     [56, 59],
158 |     63,
159 |     67,
160 |     6,
161 |   ],
162 |   gaps: [4, 8, 12],
163 |   lengths: [12, 13, 14, 15, 16, 17, 18, 19],
164 |   code: {
165 |     name: 'CVC',
166 |     size: 3,
167 |   },
168 | };
169 | 
170 | const ELO: CreditCardType = {
171 |   niceType: 'Elo',
172 |   type: 'elo',
173 |   patterns: [
174 |     401178,
175 |     401179,
176 |     438935,
177 |     457631,
178 |     457632,
179 |     431274,
180 |     451416,
181 |     457393,
182 |     504175,
183 |     [506699, 506778],
184 |     [509000, 509999],
185 |     627780,
186 |     636297,
187 |     636368,
188 |     [650031, 650033],
189 |     [650035, 650051],
190 |     [650405, 650439],
191 |     [650485, 650538],
192 |     [650541, 650598],
193 |     [650700, 650718],
194 |     [650720, 650727],
195 |     [650901, 650978],
196 |     [651652, 651679],
197 |     [655000, 655019],
198 |     [655021, 655058],
199 |   ],
200 |   gaps: [4, 8, 12],
201 |   lengths: [16],
202 |   code: {
203 |     name: 'CVE',
204 |     size: 3,
205 |   },
206 | };
207 | 
208 | const MIR: CreditCardType = {
209 |   niceType: 'Mir',
210 |   type: 'mir',
211 |   patterns: [[2200, 2204]],
212 |   gaps: [4, 8, 12],
213 |   lengths: [16, 17, 18, 19],
214 |   code: {
215 |     name: 'CVP2',
216 |     size: 3,
217 |   },
218 | };
219 | 
220 | const HIPER: CreditCardType = {
221 |   niceType: 'Hiper',
222 |   type: 'hiper',
223 |   patterns: [637095, 63737423, 63743358, 637568, 637599, 637609, 637612],
224 |   gaps: [4, 8, 12],
225 |   lengths: [16],
226 |   code: {
227 |     name: 'CVC',
228 |     size: 3,
229 |   },
230 | };
231 | 
232 | const HIPERCARD: CreditCardType = {
233 |   niceType: 'Hipercard',
234 |   type: 'hipercard',
235 |   patterns: [606282],
236 |   gaps: [4, 8, 12],
237 |   lengths: [16],
238 |   code: {
239 |     name: 'CVC',
240 |     size: 3,
241 |   },
242 | };
243 | 
244 | const DEFAULT_CARD_TYPES: CreditCardType[] = [
245 |   VISA,
246 |   MASTERCARD,
247 |   AMERICAN_EXPRESS,
248 |   DINERS_CLUB,
249 |   DISCOVER,
250 |   JCB,
251 |   UNION_PAY,
252 |   MAESTRO,
253 |   ELO,
254 |   MIR,
255 |   HIPER,
256 |   HIPERCARD,
257 | ];
258 | 
259 | export {
260 |   AMERICAN_EXPRESS,
261 |   DEFAULT_CARD_TYPES,
262 |   DINERS_CLUB,
263 |   DISCOVER,
264 |   ELO,
265 |   HIPER,
266 |   HIPERCARD,
267 |   JCB,
268 |   MAESTRO,
269 |   MASTERCARD,
270 |   MIR,
271 |   UNION_PAY,
272 |   VISA,
273 | };
274 | 
275 | export type { CreditCardType };
276 | 


--------------------------------------------------------------------------------
/src/types/elements/elements.ts:
--------------------------------------------------------------------------------
  1 | import type { HttpClient } from '@/types/sdk';
  2 | import type {
  3 |   CardElementEvents,
  4 |   CardExpirationDateElementEvents,
  5 |   CardNumberElementEvents,
  6 |   CardVerificationCodeElementEvents,
  7 |   ElementEventListener,
  8 |   EventType,
  9 |   Subscription,
 10 |   TextElementEvents,
 11 | } from './events';
 12 | import type {
 13 |   CardElementValue,
 14 |   CardExpirationDateValue,
 15 |   CreateCardElementOptions,
 16 |   CreateCardExpirationDateElementOptions,
 17 |   CreateCardNumberElementOptions,
 18 |   CreateCardVerificationCodeElementOptions,
 19 |   CreateTextElementOptions,
 20 |   UpdateCardElementOptions,
 21 |   UpdateCardExpirationDateElementOptions,
 22 |   UpdateCardNumberElementOptions,
 23 |   UpdateCardVerificationCodeElementOptions,
 24 |   UpdateTextElementOptions,
 25 | } from './options';
 26 | import type { Proxy, Tokenize, Tokens, TokenIntents } from './services';
 27 | import type {
 28 |   CardMetadata,
 29 |   DataElementReference,
 30 |   ElementMetadata,
 31 | } from './shared';
 32 | 
 33 | interface BaseElement<UpdateOptions, ElementEvents> {
 34 |   readonly mounted: boolean;
 35 |   readonly metadata: ElementMetadata;
 36 |   mount(selector: string): Promise<void>;
 37 |   mount(element: Element): Promise<void>;
 38 |   update(options: UpdateOptions): Promise<void>;
 39 |   clear(): void;
 40 |   focus(): void;
 41 |   blur(): void;
 42 |   unmount(): void;
 43 |   on<T extends EventType>(
 44 |     eventType: T,
 45 |     listener: ElementEventListener<ElementEvents, T>
 46 |   ): Subscription;
 47 | }
 48 | 
 49 | type CardElement = BaseElement<UpdateCardElementOptions, CardElementEvents> & {
 50 |   readonly cardMetadata?: CardMetadata;
 51 |   setValue(value: CardElementValue<'reference'>): void;
 52 |   validate(): void;
 53 | };
 54 | 
 55 | type TextElement = BaseElement<UpdateTextElementOptions, TextElementEvents> & {
 56 |   setValueRef(value: TextElement): void;
 57 |   setValue(value: DataElementReference): void;
 58 | };
 59 | 
 60 | type CardNumberElement = BaseElement<
 61 |   UpdateCardNumberElementOptions,
 62 |   CardNumberElementEvents
 63 | > & {
 64 |   readonly cardMetadata?: CardMetadata;
 65 |   setValueRef(value: CardNumberElement): void;
 66 |   setValue(value: DataElementReference): void;
 67 | };
 68 | 
 69 | type CardExpirationDateElement = BaseElement<
 70 |   UpdateCardExpirationDateElementOptions,
 71 |   CardExpirationDateElementEvents
 72 | > & {
 73 |   setValueRef(value: CardExpirationDateElement): void;
 74 |   setValue(value: CardExpirationDateValue<'reference'>): void;
 75 |   month(): ElementWrapper<CardExpirationDateElement>;
 76 |   year(): ElementWrapper<CardExpirationDateElement>;
 77 |   format(dateFormat: string): ElementWrapper<CardExpirationDateElement>;
 78 | };
 79 | 
 80 | type CardVerificationCodeElement = BaseElement<
 81 |   UpdateCardVerificationCodeElementOptions,
 82 |   CardVerificationCodeElementEvents
 83 | > & {
 84 |   setValueRef(value: CardVerificationCodeElement): void;
 85 |   setValue(value: DataElementReference): void;
 86 | };
 87 | 
 88 | // eslint-disable-next-line @typescript-eslint/no-explicit-any
 89 | type ElementWrapper<T extends BaseElement<any, any> = BaseElement<any, any>> = {
 90 |   element: T;
 91 |   method?: string;
 92 |   formattingOptions?: { format: string };
 93 | };
 94 | 
 95 | type ElementValue =
 96 |   | TextElement
 97 |   | CardElement
 98 |   | CardNumberElement
 99 |   | CardExpirationDateElement
100 |   | CardVerificationCodeElement
101 |   | ElementWrapper;
102 | 
103 | interface BasisTheoryElements extends Tokenize {
104 |   tokens: Tokens;
105 |   proxy: Proxy;
106 |   tokenIntents: TokenIntents;
107 | 
108 |   createElement(type: 'card', options?: CreateCardElementOptions): CardElement;
109 |   createElement(type: 'text', options: CreateTextElementOptions): TextElement;
110 |   createElement(
111 |     type: 'cardNumber',
112 |     options: CreateCardNumberElementOptions
113 |   ): CardNumberElement;
114 |   createElement(
115 |     type: 'cardExpirationDate',
116 |     options: CreateCardExpirationDateElementOptions
117 |   ): CardExpirationDateElement;
118 |   createElement(
119 |     type: 'cardVerificationCode',
120 |     options: CreateCardVerificationCodeElementOptions
121 |   ): CardVerificationCodeElement;
122 | }
123 | interface BasisTheoryElementsInternal extends BasisTheoryElements {
124 |   init: (
125 |     apiKey: string | undefined,
126 |     elementsBaseUrl: string,
127 |     elementsUseNgApi: boolean | undefined,
128 |     elementsUseSameOriginApi: boolean | undefined,
129 |     disableTelemetry: boolean | undefined,
130 |     debug: boolean | undefined
131 |   ) => Promise<BasisTheoryElements>;
132 |   hasElement: (payload: unknown) => boolean;
133 |   client: HttpClient;
134 | }
135 | 
136 | declare global {
137 |   interface Window {
138 |     BasisTheoryElements?: BasisTheoryElementsInternal;
139 |   }
140 | }
141 | 
142 | export type {
143 |   BaseElement,
144 |   CardElement,
145 |   TextElement,
146 |   CardNumberElement,
147 |   CardExpirationDateElement,
148 |   CardVerificationCodeElement,
149 |   ElementWrapper,
150 |   ElementValue,
151 |   BasisTheoryElements,
152 |   BasisTheoryElementsInternal,
153 | };
154 | 


--------------------------------------------------------------------------------
/src/types/elements/events.ts:
--------------------------------------------------------------------------------
 1 | import type {
 2 |   CardMetadata,
 3 |   ElementMetadata,
 4 |   ListenableKey,
 5 |   Targeted,
 6 | } from './shared';
 7 | 
 8 | type EventType = 'ready' | 'change' | 'focus' | 'blur' | 'keydown';
 9 | 
10 | interface BaseEvent<T extends EventType> {
11 |   type: T;
12 | }
13 | 
14 | type ReadyEvent = BaseEvent<'ready'>;
15 | 
16 | type ChangeEvent = BaseEvent<'change'> & ElementMetadata;
17 | 
18 | type BlurEvent = BaseEvent<'blur'> & ElementMetadata;
19 | 
20 | type CardChangeEvent = ChangeEvent & CardMetadata;
21 | 
22 | type InputFocusEvent = BaseEvent<'focus'> & Targeted;
23 | 
24 | type InputBlurEvent = BlurEvent & Targeted;
25 | 
26 | type InputKeydownEvent = BaseEvent<'keydown'> &
27 |   Targeted & {
28 |     key: ListenableKey;
29 |   } & Pick<KeyboardEvent, 'altKey' | 'ctrlKey' | 'shiftKey' | 'metaKey'>;
30 | 
31 | type BaseElementEvents =
32 |   | ReadyEvent
33 |   | InputFocusEvent
34 |   | InputBlurEvent
35 |   | InputKeydownEvent;
36 | 
37 | type TextElementEvents = BaseElementEvents | ChangeEvent;
38 | 
39 | type CardElementEvents = BaseElementEvents | CardChangeEvent;
40 | 
41 | type CardNumberElementEvents = BaseElementEvents | CardChangeEvent;
42 | 
43 | type CardExpirationDateElementEvents = BaseElementEvents | ChangeEvent;
44 | 
45 | type CardVerificationCodeElementEvents = BaseElementEvents | ChangeEvent;
46 | 
47 | /**
48 |  * Utility type that helps find a Union type based on a `type` property
49 |  */
50 | type FindByType<Union, Type> = Union extends { type: Type } ? Union : never;
51 | 
52 | type ElementEventListener<Events, Type> = (
53 |   event: FindByType<Events, Type>
54 | ) => void;
55 | 
56 | interface Subscription {
57 |   unsubscribe(): void;
58 | }
59 | 
60 | export type {
61 |   EventType,
62 |   BaseEvent,
63 |   ReadyEvent,
64 |   ChangeEvent,
65 |   CardChangeEvent,
66 |   InputFocusEvent,
67 |   InputBlurEvent,
68 |   InputKeydownEvent,
69 |   BaseElementEvents,
70 |   TextElementEvents,
71 |   CardElementEvents,
72 |   CardNumberElementEvents,
73 |   CardExpirationDateElementEvents,
74 |   CardVerificationCodeElementEvents,
75 |   ElementEventListener,
76 |   Subscription,
77 | };
78 | 


--------------------------------------------------------------------------------
/src/types/elements/index.ts:
--------------------------------------------------------------------------------
1 | export * from './cardTypes';
2 | export * from './elements';
3 | export * from './events';
4 | export * from './options';
5 | export * from './services';
6 | export * from './shared';
7 | export * from './styles';
8 | 


--------------------------------------------------------------------------------
/src/types/elements/options.ts:
--------------------------------------------------------------------------------
  1 | import { CreditCardType } from './cardTypes';
  2 | import { AutoCompleteValue, DataElementReference } from './shared';
  3 | import type { CopyIconStyles, ElementStyle } from './styles';
  4 | 
  5 | const ELEMENTS_TYPES = [
  6 |   'card',
  7 |   'cardExpirationDate',
  8 |   'cardNumber',
  9 |   'cardVerificationCode',
 10 |   'data',
 11 |   'text',
 12 | ] as const;
 13 | 
 14 | type ElementType = typeof ELEMENTS_TYPES[number];
 15 | 
 16 | interface ElementInternalOptions {
 17 |   apiKey: string | undefined;
 18 |   baseUrl: string;
 19 |   type: ElementType;
 20 |   useNgApi: boolean | undefined;
 21 |   useSameOriginApi: boolean | undefined;
 22 |   disableTelemetry?: boolean | undefined;
 23 |   debug?: boolean | undefined;
 24 | }
 25 | 
 26 | enum InputMode {
 27 |   DECIMAL = 'decimal',
 28 |   EMAIL = 'email',
 29 |   NONE = 'none',
 30 |   NUMERIC = 'numeric',
 31 |   SEARCH = 'search',
 32 |   TEL = 'tel',
 33 |   TEXT = 'text',
 34 |   URL = 'url',
 35 | }
 36 | 
 37 | interface SanitizedElementOptions {
 38 |   ariaDescription?: string;
 39 |   ariaLabel?: string;
 40 |   autoComplete?: AutoCompleteValue;
 41 |   cardBrand?: string;
 42 |   cardTypes?: CreditCardType[];
 43 |   copyIconStyles?: CopyIconStyles;
 44 |   disabled?: boolean;
 45 |   enableCopy?: boolean;
 46 |   iconPosition?: string;
 47 |   inputMode?: `${InputMode}`;
 48 |   mask?: (RegExp | string)[];
 49 |   maxLength?: HTMLInputElement['maxLength'];
 50 |   password?: boolean;
 51 |   placeholder?: string;
 52 |   readOnly?: boolean;
 53 |   skipLuhnValidation?: boolean;
 54 |   style?: ElementStyle;
 55 |   targetId?: string;
 56 |   transform?: [RegExp, string] | null;
 57 |   validateOnChange?: boolean;
 58 |   validation?: RegExp;
 59 |   value?:
 60 |     | CardElementValue<'static'>
 61 |     | CardExpirationDateValue<'static'>
 62 |     | string;
 63 | }
 64 | 
 65 | type ElementOptions = ElementInternalOptions & SanitizedElementOptions;
 66 | 
 67 | type Transform = RegExp | [RegExp, string?] | null;
 68 | 
 69 | interface TransformOption {
 70 |   transform?: Transform;
 71 | }
 72 | 
 73 | interface AutoCompleteOption {
 74 |   autoComplete?: AutoCompleteValue;
 75 | }
 76 | 
 77 | type CustomizableElementOptions = Pick<
 78 |   ElementOptions,
 79 |   | 'cardTypes'
 80 |   | 'copyIconStyles'
 81 |   | 'disabled'
 82 |   | 'enableCopy'
 83 |   | 'inputMode'
 84 |   | 'readOnly'
 85 |   | 'skipLuhnValidation'
 86 |   | 'style'
 87 |   | 'validateOnChange'
 88 | > &
 89 |   AutoCompleteOption;
 90 | 
 91 | type ElementValueType = 'static' | 'reference';
 92 | 
 93 | interface CardElementValue<T extends ElementValueType> {
 94 |   cvc?: T extends 'reference' ? DataElementReference : string;
 95 |   expiration_month?: T extends 'reference' ? DataElementReference : number;
 96 |   expiration_year?: T extends 'reference' ? DataElementReference : number;
 97 |   number?: T extends 'reference' ? DataElementReference : string;
 98 | }
 99 | 
100 | interface CardElementPlaceholder {
101 |   cardNumber?: string;
102 |   cardExpirationDate?: string;
103 |   cardSecurityCode?: string;
104 | }
105 | 
106 | interface CardExpirationDateValue<T extends ElementValueType> {
107 |   month: T extends 'reference' ? DataElementReference : number;
108 |   year: T extends 'reference' ? DataElementReference : number;
109 | }
110 | 
111 | type CreateCardElementOptions = CustomizableElementOptions &
112 |   Pick<ElementOptions, 'cardTypes' | 'skipLuhnValidation'> & {
113 |     placeholder?: CardElementPlaceholder;
114 |     value?: CardElementValue<'static'>;
115 |   };
116 | 
117 | type UpdateCardElementOptions = Omit<
118 |   CreateCardElementOptions,
119 |   'validateOnChange' | 'enableCopy'
120 | >;
121 | 
122 | type CreateTextElementOptions = CustomizableElementOptions &
123 |   Pick<
124 |     ElementOptions,
125 |     'placeholder' | 'mask' | 'maxLength' | 'password' | 'validation'
126 |   > &
127 |   TransformOption &
128 |   Required<Pick<ElementOptions, 'targetId'>> & {
129 |     'aria-label'?: string;
130 |     value?: string;
131 |   };
132 | 
133 | type UpdateTextElementOptions = Omit<
134 |   CreateTextElementOptions,
135 |   'targetId' | 'mask' | 'validateOnChange'
136 | >;
137 | 
138 | type CreateCardNumberElementOptions = CustomizableElementOptions &
139 |   Pick<
140 |     ElementOptions,
141 |     'placeholder' | 'iconPosition' | 'cardTypes' | 'skipLuhnValidation'
142 |   > &
143 |   Required<Pick<ElementOptions, 'targetId'>> & {
144 |     'aria-label'?: string;
145 |     value?: string;
146 |   };
147 | 
148 | type UpdateCardNumberElementOptions = Omit<
149 |   CreateCardNumberElementOptions,
150 |   'targetId' | 'validateOnChange' | 'enableCopy'
151 | >;
152 | 
153 | type CreateCardExpirationDateElementOptions = CustomizableElementOptions &
154 |   Pick<ElementOptions, 'placeholder'> &
155 |   Required<Pick<ElementOptions, 'targetId'>> & {
156 |     'aria-label'?: string;
157 |     value?: CardExpirationDateValue<'static'> | string;
158 |   };
159 | 
160 | type UpdateCardExpirationDateElementOptions = Omit<
161 |   CreateCardExpirationDateElementOptions,
162 |   'targetId' | 'validateOnChange' | 'enableCopy'
163 | >;
164 | 
165 | type CreateCardVerificationCodeElementOptions = CustomizableElementOptions &
166 |   Pick<ElementOptions, 'placeholder' | 'cardBrand'> &
167 |   Required<Pick<ElementOptions, 'targetId'>> & {
168 |     'aria-label'?: string;
169 |     value?: string;
170 |   };
171 | 
172 | type UpdateCardVerificationCodeElementOptions = Omit<
173 |   CreateCardVerificationCodeElementOptions,
174 |   'targetId' | 'validateOnChange' | 'enableCopy'
175 | >;
176 | 
177 | export type {
178 |   CardElementPlaceholder,
179 |   CardElementValue,
180 |   CardExpirationDateValue,
181 |   CreateCardElementOptions,
182 |   CreateCardExpirationDateElementOptions,
183 |   CreateCardNumberElementOptions,
184 |   CreateCardVerificationCodeElementOptions,
185 |   CreateTextElementOptions,
186 |   CustomizableElementOptions,
187 |   ElementInternalOptions,
188 |   ElementOptions,
189 |   ElementType,
190 |   InputMode,
191 |   SanitizedElementOptions,
192 |   Transform,
193 |   UpdateCardElementOptions,
194 |   UpdateCardExpirationDateElementOptions,
195 |   UpdateCardNumberElementOptions,
196 |   UpdateCardVerificationCodeElementOptions,
197 |   UpdateTextElementOptions,
198 | };
199 | 
200 | export { ELEMENTS_TYPES };
201 | 


--------------------------------------------------------------------------------
/src/types/elements/services/index.ts:
--------------------------------------------------------------------------------
1 | export * from './tokenize';
2 | export * from './tokens';
3 | export * from './proxy';
4 | export * from './token-intents';
5 | 


--------------------------------------------------------------------------------
/src/types/elements/services/proxy.ts:
--------------------------------------------------------------------------------
 1 | import type { ProxyRequestOptions } from '@/types/sdk';
 2 | 
 3 | interface Proxy {
 4 |   get(options?: ProxyRequestOptions): Promise<any>;
 5 |   post(options?: ProxyRequestOptions): Promise<any>;
 6 |   patch(options?: ProxyRequestOptions): Promise<any>;
 7 |   put(options?: ProxyRequestOptions): Promise<any>;
 8 |   delete(options?: ProxyRequestOptions): Promise<any>;
 9 | }
10 | 
11 | export type { Proxy };
12 | 


--------------------------------------------------------------------------------
/src/types/elements/services/token-intents.ts:
--------------------------------------------------------------------------------
 1 | import type { ElementValue } from '@/types/elements';
 2 | import type {
 3 |   CreateTokenIntent as CreateTokenIntentModel,
 4 |   TokenIntent,
 5 | } from '@/types/models';
 6 | import type { Create } from '@/types/sdk';
 7 | 
 8 | type CreateTokenIntent = CreateTokenIntentModel<ElementValue>;
 9 | 
10 | type TokenIntents = Create<TokenIntent, CreateTokenIntent>;
11 | 
12 | export type { TokenIntents, CreateTokenIntent };
13 | 


--------------------------------------------------------------------------------
/src/types/elements/services/tokenize.ts:
--------------------------------------------------------------------------------
 1 | import type { ElementValue } from '@/types/elements';
 2 | import type { TokenizeData as TokenizeDataModel } from '@/types/models';
 3 | import type { RequestOptions } from '@/types/sdk';
 4 | 
 5 | type TokenizeData = TokenizeDataModel<ElementValue>;
 6 | 
 7 | interface Tokenize {
 8 |   tokenize(
 9 |     tokens: TokenizeData,
10 |     options?: RequestOptions
11 |   ): Promise<TokenizeDataModel>;
12 | }
13 | 
14 | export type { Tokenize, TokenizeData };
15 | 


--------------------------------------------------------------------------------
/src/types/elements/services/tokens.ts:
--------------------------------------------------------------------------------
 1 | import type { ElementValue } from '@/types/elements';
 2 | import type {
 3 |   CreateToken as CreateTokenModel,
 4 |   UpdateToken as UpdateTokenModel,
 5 |   Token,
 6 | } from '@/types/models';
 7 | import type { Create, Retrieve, Update } from '@/types/sdk';
 8 | 
 9 | type CreateToken = CreateTokenModel<ElementValue>;
10 | type UpdateToken = UpdateTokenModel<ElementValue>;
11 | 
12 | type Tokens = Create<Token, CreateToken> &
13 |   // avoid casting when accessing token data props
14 |   // eslint-disable-next-line @typescript-eslint/no-explicit-any
15 |   Retrieve<Token<any>> &
16 |   Update<Token, UpdateToken>;
17 | 
18 | export type { Tokens, CreateToken, UpdateToken };
19 | 


--------------------------------------------------------------------------------
/src/types/elements/shared.ts:
--------------------------------------------------------------------------------
 1 | import {
 2 |   AUTOCOMPLETE_VALUES,
 3 |   CARD_BRANDS,
 4 |   CARD_ICON_POSITIONS,
 5 | } from '@/elements/constants';
 6 | 
 7 | type FieldErrorType = 'incomplete' | 'invalid';
 8 | 
 9 | type ConfigErrorType =
10 |   | 'missing-configuration'
11 |   | 'missing-permission'
12 |   | 'invalid-configuration';
13 | 
14 | interface ConfigError {
15 |   type: ConfigErrorType;
16 |   message: string;
17 | }
18 | 
19 | interface Targeted {
20 |   targetId: string;
21 | }
22 | 
23 | type ListenableKey = 'Escape' | 'Enter';
24 | 
25 | interface FieldError {
26 |   targetId: string;
27 |   type: FieldErrorType;
28 | }
29 | 
30 | interface PropertyError {
31 |   type: FieldErrorType;
32 | }
33 | 
34 | interface ElementMetadata {
35 |   complete: boolean;
36 |   empty: boolean;
37 |   errors?: FieldError[] | Omit<FieldError, 'targetId'>[];
38 |   maskSatisfied?: boolean;
39 |   valid: boolean;
40 | }
41 | 
42 | interface CardMetadata {
43 |   cardBin?: string;
44 |   cardBrand: Brand;
45 |   cardLast4?: string;
46 | }
47 | 
48 | /**
49 |  * Card brands type
50 |  */
51 | type Brand = typeof CARD_BRANDS[number];
52 | 
53 | /**
54 |  * Icon position for card number element
55 |  */
56 | type CardIconPosition = typeof CARD_ICON_POSITIONS[number];
57 | 
58 | /**
59 |  * Values for the element input autocomplete attribute
60 |  */
61 | type AutoCompleteValue = typeof AUTOCOMPLETE_VALUES[number];
62 | 
63 | /**
64 |  * Type used for detokenization responses stored on Data Elements
65 |  */
66 | type DataElementReference = {
67 |   correlationId: string;
68 |   elementId: string;
69 |   path: string;
70 | };
71 | 
72 | export type {
73 |   AutoCompleteValue,
74 |   Brand,
75 |   CardIconPosition,
76 |   CardMetadata,
77 |   ConfigError,
78 |   ConfigErrorType,
79 |   DataElementReference,
80 |   ElementMetadata,
81 |   FieldError,
82 |   FieldErrorType,
83 |   ListenableKey,
84 |   PropertyError,
85 |   Targeted,
86 | };
87 | 


--------------------------------------------------------------------------------
/src/types/elements/styles.ts:
--------------------------------------------------------------------------------
  1 | import type { Properties as CSSProperties } from 'csstype';
  2 | 
  3 | const SAFE_CSS_PROPERTIES = [
  4 |   'backgroundColor',
  5 |   'color',
  6 |   'fontFamily',
  7 |   'fontSize',
  8 |   'fontSmooth',
  9 |   'fontStyle',
 10 |   'fontVariant',
 11 |   'fontWeight',
 12 |   'lineHeight',
 13 |   'letterSpacing',
 14 |   'textAlign',
 15 |   'padding',
 16 |   'textDecoration',
 17 |   'textShadow',
 18 |   'textTransform',
 19 | ] as const;
 20 | 
 21 | type SafeCSSProperty = typeof SAFE_CSS_PROPERTIES[number];
 22 | 
 23 | const SAFE_CSS_PROPERTIES_ALTERNATES: Partial<
 24 |   Record<SafeCSSProperty, string[]>
 25 | > = {
 26 |   fontSmooth: ['-webkit-font-smoothing', '-moz-osx-font-smoothing'],
 27 | };
 28 | 
 29 | const SAFE_CSS_PROPERTIES_WITH_ALTERNATES = Object.keys(
 30 |   SAFE_CSS_PROPERTIES_ALTERNATES
 31 | );
 32 | 
 33 | type SafeStyle = Pick<CSSProperties, SafeCSSProperty>;
 34 | 
 35 | const CARD_ELEMENT_STYLE_VARIANT_SELECTORS = [
 36 |   ':hover',
 37 |   ':focus',
 38 |   ':read-only',
 39 |   '::placeholder',
 40 |   '::selection',
 41 |   ':disabled',
 42 | ] as const;
 43 | 
 44 | type CardElementStyleVariantSelector = typeof CARD_ELEMENT_STYLE_VARIANT_SELECTORS[number];
 45 | 
 46 | type CardElementStyleVariantStyle = SafeStyle &
 47 |   Partial<Record<CardElementStyleVariantSelector, SafeStyle>>;
 48 | 
 49 | const CARD_ELEMENT_STYLE_VARIANTS = [
 50 |   'base',
 51 |   'complete',
 52 |   'invalid',
 53 |   'empty',
 54 | ] as const;
 55 | 
 56 | const CARD_ELEMENT_STYLE_FONTS_ATTR = 'fonts' as const;
 57 | 
 58 | type CardElementStyleVariant = typeof CARD_ELEMENT_STYLE_VARIANTS[number];
 59 | 
 60 | type CardElementStyleFontAttr = typeof CARD_ELEMENT_STYLE_FONTS_ATTR;
 61 | 
 62 | type FontSource = string; // this could turn into an object in the future, to specify the font face attrs individually
 63 | type FontSources = FontSource[];
 64 | 
 65 | type Fonts = Record<CardElementStyleFontAttr, FontSources>;
 66 | 
 67 | type CardElementStyle = Partial<
 68 |   Record<CardElementStyleVariant, CardElementStyleVariantStyle> & Fonts
 69 | >;
 70 | 
 71 | type ElementStyle = CardElementStyle; // add others here as union type
 72 | 
 73 | type CopyIconStyles = {
 74 |   size?: string;
 75 |   color?: string;
 76 |   successColor?: string;
 77 | };
 78 | 
 79 | export {
 80 |   SAFE_CSS_PROPERTIES,
 81 |   SAFE_CSS_PROPERTIES_ALTERNATES,
 82 |   SAFE_CSS_PROPERTIES_WITH_ALTERNATES,
 83 |   CARD_ELEMENT_STYLE_VARIANT_SELECTORS,
 84 |   CARD_ELEMENT_STYLE_VARIANTS,
 85 |   CARD_ELEMENT_STYLE_FONTS_ATTR,
 86 | };
 87 | 
 88 | export type {
 89 |   CardElementStyle,
 90 |   CardElementStyleVariant,
 91 |   CardElementStyleVariantSelector,
 92 |   CardElementStyleVariantStyle,
 93 |   CopyIconStyles,
 94 |   ElementStyle,
 95 |   Fonts,
 96 |   FontSources,
 97 |   SafeCSSProperty,
 98 |   SafeStyle,
 99 | };
100 | 


--------------------------------------------------------------------------------
/src/types/models/application-templates.ts:
--------------------------------------------------------------------------------
 1 | import type { ApplicationType, AccessRule } from './applications';
 2 | 
 3 | const TEMPLATE_TYPES = [
 4 |   'starters',
 5 |   'payments',
 6 |   'banking',
 7 |   'pii',
 8 |   'management',
 9 | ] as const;
10 | 
11 | type TemplateType = typeof TEMPLATE_TYPES[number];
12 | 
13 | interface ApplicationTemplate {
14 |   id: string;
15 |   name: string;
16 |   description: string;
17 |   applicationType: ApplicationType;
18 |   templateType: TemplateType;
19 |   isStarter: boolean;
20 |   permissions?: string[];
21 |   rules?: AccessRule[];
22 | }
23 | 
24 | export type { TemplateType, ApplicationTemplate };
25 | 
26 | export { TEMPLATE_TYPES };
27 | 


--------------------------------------------------------------------------------
/src/types/models/applications.ts:
--------------------------------------------------------------------------------
 1 | import type { Auditable } from './shared';
 2 | 
 3 | const APPLICATION_TYPES = ['private', 'public', 'management'] as const;
 4 | const TRANSFORM_TYPES = ['mask', 'redact', 'reveal'] as const;
 5 | 
 6 | type ApplicationType = typeof APPLICATION_TYPES[number];
 7 | type TransformType = typeof TRANSFORM_TYPES[number];
 8 | 
 9 | interface Application extends Auditable {
10 |   id: string;
11 |   tenantId: string;
12 |   name?: string;
13 |   /**
14 |    * @deprecated use `keys` instead.
15 |    */
16 |   key?: string;
17 |   keys?: ApplicationKey[];
18 |   type: ApplicationType;
19 |   permissions?: string[];
20 |   rules?: AccessRule[];
21 |   expiresAt?: string;
22 | }
23 | 
24 | interface AccessRule {
25 |   description: string;
26 |   priority: number;
27 |   container?: string;
28 |   transform: TransformType;
29 |   permissions: string[];
30 |   conditions?: Condition[];
31 | }
32 | 
33 | type Condition = {
34 |   attribute: string;
35 |   operator: string;
36 |   value: string;
37 | };
38 | 
39 | type ApplicationKey = {
40 |   id?: string;
41 |   key?: string;
42 |   createdAt?: string;
43 |   createdBy?: string;
44 | };
45 | 
46 | type CreateApplication = Pick<
47 |   Application,
48 |   'name' | 'type' | 'permissions' | 'rules' | 'expiresAt'
49 | > & { createKey?: boolean };
50 | 
51 | type UpdateApplication = Pick<Application, 'name' | 'permissions' | 'rules'>;
52 | 
53 | export type {
54 |   Application,
55 |   ApplicationKey,
56 |   ApplicationType,
57 |   CreateApplication,
58 |   TransformType,
59 |   UpdateApplication,
60 | };
61 | export { APPLICATION_TYPES, TRANSFORM_TYPES, AccessRule };
62 | 


--------------------------------------------------------------------------------
/src/types/models/banks.ts:
--------------------------------------------------------------------------------
1 | interface Bank {
2 |   routingNumber: string;
3 |   accountNumber: string;
4 | }
5 | 
6 | export type { Bank };
7 | 


--------------------------------------------------------------------------------
/src/types/models/bin-details.ts:
--------------------------------------------------------------------------------
 1 | /* eslint-disable @typescript-eslint/no-explicit-any */
 2 | interface BinDetails {
 3 |   cardBrand?: string;
 4 |   type?: string;
 5 |   prepaid?: boolean;
 6 |   cardSegmentType?: string;
 7 |   reloadable?: boolean;
 8 |   panOrToken?: string;
 9 |   accountUpdater?: boolean;
10 |   alm?: boolean;
11 |   domesticOnly?: boolean;
12 |   gamblingBlocked?: boolean;
13 |   level2?: boolean;
14 |   level3?: boolean;
15 |   issuerCurrency?: string;
16 |   comboCard?: string;
17 |   binLength?: number;
18 |   authentication?: any;
19 |   cost?: any;
20 |   bank?: BinDetailsBank;
21 |   country?: BinDetailsCountry;
22 |   product?: BinDetailsProduct;
23 | }
24 | /* eslint-enable @typescript-eslint/no-explicit-any */
25 | 
26 | interface BinDetailsBank {
27 |   name?: string;
28 |   phone?: string;
29 |   url?: string;
30 |   cleanName?: string;
31 | }
32 | 
33 | interface BinDetailsCountry {
34 |   alpha2?: string;
35 |   name?: string;
36 |   numeric?: string;
37 | }
38 | 
39 | interface BinDetailsProduct {
40 |   code?: string;
41 |   name?: string;
42 | }
43 | 
44 | export type {
45 |   BinDetails,
46 |   BinDetailsBank,
47 |   BinDetailsCountry,
48 |   BinDetailsProduct,
49 | };
50 | 


--------------------------------------------------------------------------------
/src/types/models/card-details.ts:
--------------------------------------------------------------------------------
 1 | interface CardDetails {
 2 |   bin?: string;
 3 |   last4?: string;
 4 |   expirationMonth?: number;
 5 |   expirationYear?: number;
 6 |   brand?: CardBrandType;
 7 |   funding?: FundingType;
 8 |   authentication?: string;
 9 | }
10 | 
11 | const enrichmentCardBrands = [
12 |   'american-express',
13 |   'diners-club',
14 |   'discover',
15 |   'ebt',
16 |   'elo',
17 |   'hiper',
18 |   'hipercard',
19 |   'jcb',
20 |   'maestro',
21 |   'mastercard',
22 |   'mir',
23 |   'private-label',
24 |   'proprietary',
25 |   'unionpay',
26 |   'visa',
27 | ] as const;
28 | 
29 | type CardBrandType = typeof enrichmentCardBrands[number];
30 | 
31 | const enrichmentFundingTypes = ['prepaid', 'credit', 'debit'] as const;
32 | 
33 | type FundingType = typeof enrichmentFundingTypes[number];
34 | 
35 | export type { CardDetails, CardBrandType, FundingType };
36 | export { enrichmentCardBrands, enrichmentFundingTypes };
37 | 


--------------------------------------------------------------------------------
/src/types/models/cards.ts:
--------------------------------------------------------------------------------
1 | interface Card {
2 |   number: string;
3 |   expirationMonth?: number;
4 |   expirationYear?: number;
5 |   cvc?: string;
6 | }
7 | 
8 | export type { Card };
9 | 


--------------------------------------------------------------------------------
/src/types/models/index.ts:
--------------------------------------------------------------------------------
 1 | export * from './tokens';
 2 | export * from './shared';
 3 | export * from './applications';
 4 | export * from './tenants';
 5 | export * from './logs';
 6 | export * from './reactor-formulas';
 7 | export * from './reactors';
 8 | export * from './permissions';
 9 | export * from './tokenize';
10 | export * from './proxies';
11 | export * from './banks';
12 | export * from './cards';
13 | export * from './bin-details';
14 | export * from './util';
15 | export * from './token-intents';
16 | 


--------------------------------------------------------------------------------
/src/types/models/logs.ts:
--------------------------------------------------------------------------------
 1 | interface Log {
 2 |   tenantId: string;
 3 |   actorId?: string;
 4 |   actorType?: string;
 5 |   entityType: string;
 6 |   entityId: string;
 7 |   operation: string;
 8 |   message: string;
 9 |   createdAt: string;
10 | }
11 | 
12 | export type { Log };
13 | 


--------------------------------------------------------------------------------
/src/types/models/permissions.ts:
--------------------------------------------------------------------------------
 1 | import type { ApplicationType } from './applications';
 2 | 
 3 | interface Permission {
 4 |   type: string;
 5 |   description: string;
 6 |   applicationTypes: ApplicationType[];
 7 | }
 8 | 
 9 | export type { Permission };
10 | 


--------------------------------------------------------------------------------
/src/types/models/proxies.ts:
--------------------------------------------------------------------------------
 1 | import type { Application } from './applications';
 2 | import type { Auditable } from './shared';
 3 | import type { Nullable } from './util';
 4 | 
 5 | interface Proxy extends Auditable {
 6 |   id: string;
 7 |   key: string;
 8 |   tenantId: string;
 9 |   name: string;
10 |   destinationUrl: string;
11 |   requestTransform?: ProxyTransform;
12 |   responseTransform?: ProxyTransform;
13 |   applicationId?: string;
14 |   configuration?: Record<string, string>;
15 |   requireAuth?: boolean;
16 | }
17 | 
18 | interface ProxyTransform {
19 |   code: string;
20 | }
21 | 
22 | type CreateProxy = Pick<
23 |   Proxy,
24 |   | 'name'
25 |   | 'destinationUrl'
26 |   | 'requestTransform'
27 |   | 'responseTransform'
28 |   | 'configuration'
29 |   | 'requireAuth'
30 | > & {
31 |   application?: Pick<Application, 'id'>;
32 | };
33 | 
34 | type UpdateProxy = CreateProxy;
35 | type PatchProxy = Omit<Partial<UpdateProxy>, 'configuration'> & {
36 |   configuration?: Nullable<UpdateProxy['configuration']>;
37 | };
38 | 
39 | export type { Proxy, CreateProxy, UpdateProxy, PatchProxy };
40 | 


--------------------------------------------------------------------------------
/src/types/models/reactor-formulas.ts:
--------------------------------------------------------------------------------
 1 | import type { Auditable } from './shared';
 2 | 
 3 | type FormulaType = 'official' | 'private';
 4 | type DataType = 'string' | 'boolean' | 'number';
 5 | 
 6 | /**
 7 |  * @deprecated Reactor Formulas are now deprecated and will be removed in a future release.
 8 |  * @description We have introduced a `code` property for Reactors to replace Formula's code. For more details visit [our API reference](https://developers.basistheory.com/docs/api/reactors#create-reactor).
 9 |  */
10 | interface ReactorFormula extends Auditable {
11 |   id: string;
12 |   name: string;
13 |   description?: string;
14 |   type: FormulaType;
15 |   icon?: string;
16 |   code: string;
17 |   configuration: ReactorFormulaConfig[];
18 |   requestParameters: ReactorFormulaRequestParam[];
19 | }
20 | 
21 | interface ReactorFormulaConfig {
22 |   name: string;
23 |   description?: string;
24 |   type: DataType;
25 | }
26 | 
27 | interface ReactorFormulaRequestParam {
28 |   name: string;
29 |   description?: string;
30 |   type: DataType;
31 |   optional?: boolean;
32 | }
33 | /**
34 |  * @deprecated Reactor Formulas are now deprecated and will be removed in a future release.
35 |  * @description We have introduced a `code` property for Reactors to replace Formula's code. For more details visit [our API reference](https://developers.basistheory.com/docs/api/reactors#create-reactor).
36 |  */
37 | type CreateReactorFormula = Omit<
38 |   ReactorFormula,
39 |   'id' | 'createdAt' | 'createdBy' | 'modifiedAt' | 'modifiedBy'
40 | >;
41 | 
42 | export type {
43 |   FormulaType,
44 |   DataType,
45 |   ReactorFormula,
46 |   ReactorFormulaConfig,
47 |   ReactorFormulaRequestParam,
48 |   CreateReactorFormula,
49 | };
50 | 


--------------------------------------------------------------------------------
/src/types/models/reactors.ts:
--------------------------------------------------------------------------------
 1 | import type { Application } from './applications';
 2 | import type { ReactorFormula } from './reactor-formulas';
 3 | import type { Auditable } from './shared';
 4 | import type { Nullable } from './util';
 5 | 
 6 | interface Reactor extends Auditable {
 7 |   id: string;
 8 |   tenantId: string;
 9 |   name: string;
10 |   application?: Application;
11 |   code?: string;
12 |   configuration?: Record<string, string>;
13 |   /**
14 |    * @deprecated Reactor Formulas are now deprecated and will be removed in a future release.
15 |    * @description We have introduced a `code` property for Reactors to replace Formula's code. For more details visit [our API reference](https://developers.basistheory.com/docs/api/reactors#create-reactor).
16 |    */
17 |   formula?: ReactorFormula;
18 | }
19 | 
20 | type CreateReactor = Pick<Reactor, 'name' | 'configuration'> & {
21 |   code?: string;
22 |   application?: Pick<Application, 'id'>;
23 | };
24 | 
25 | type UpdateReactor = Pick<Reactor, 'name' | 'configuration' | 'code'> & {
26 |   application?: Pick<Application, 'id'>;
27 | };
28 | 
29 | type PatchReactor = Omit<Partial<UpdateReactor>, 'configuration'> & {
30 |   configuration?: Nullable<UpdateReactor['configuration']>;
31 | };
32 | 
33 | export type { Reactor, CreateReactor, UpdateReactor, PatchReactor };
34 | 


--------------------------------------------------------------------------------
/src/types/models/shared.ts:
--------------------------------------------------------------------------------
 1 | type Primitive = string | number | boolean | null;
 2 | type TokenType =
 3 |   | 'token'
 4 |   | 'card'
 5 |   | 'bank'
 6 |   | 'card_number'
 7 |   | 'us_bank_routing_number'
 8 |   | 'us_bank_account_number'
 9 |   | 'social_security_number';
10 | 
11 | interface Auditable {
12 |   createdBy?: string;
13 |   createdAt?: string;
14 |   modifiedBy?: string;
15 |   modifiedAt?: string;
16 | }
17 | 
18 | type DataObject<DataType = Primitive> = {
19 |   [member: string]: TokenData<DataType>;
20 | };
21 | type DataArray<DataType> = Array<TokenData<DataType>>;
22 | type TokenData<DataType = Primitive> =
23 |   | Primitive
24 |   | DataObject<DataType>
25 |   | DataArray<DataType>
26 |   | DataType;
27 | 
28 | interface TokenBase<DataType = Primitive> extends Auditable {
29 |   data: TokenData<DataType>;
30 |   type: TokenType;
31 | }
32 | 
33 | interface ReactResponse {
34 |   tokens: DataObject;
35 |   raw: DataObject;
36 | }
37 | 
38 | export type {
39 |   Primitive,
40 |   Auditable,
41 |   TokenType,
42 |   TokenBase,
43 |   ReactResponse,
44 |   DataObject,
45 | };
46 | 


--------------------------------------------------------------------------------
/src/types/models/tenants.ts:
--------------------------------------------------------------------------------
 1 | import type { Auditable } from './shared';
 2 | 
 3 | interface Tenant extends Auditable {
 4 |   id: string;
 5 |   ownerId: string;
 6 |   name: string;
 7 |   settings?: Record<string, string>;
 8 | }
 9 | 
10 | type UpdateTenant = Pick<Tenant, 'name' | 'settings'>;
11 | 
12 | interface TenantUsageReport {
13 |   tokenReport: TokenReport;
14 |   totalTokens: number;
15 | }
16 | 
17 | interface TokenReport {
18 |   totalTokens: number;
19 |   includedMonthlyActiveTokens: number;
20 |   monthlyActiveTokens: number;
21 | }
22 | 
23 | interface TokenTypeMetrics {
24 |   count: number;
25 |   lastCreatedAt?: string;
26 | }
27 | 
28 | interface TenantInvitation extends Auditable {
29 |   id: string;
30 |   tenantId: string;
31 |   email: string;
32 |   status: string;
33 |   expiresAt: string;
34 | }
35 | 
36 | type CreateTenantInvitation = Pick<TenantInvitation, 'email'>;
37 | 
38 | interface User {
39 |   id: string;
40 |   email?: string;
41 |   firstName?: string;
42 |   lastName?: string;
43 |   picture?: string;
44 | }
45 | 
46 | interface TenantMember extends Auditable {
47 |   id: string;
48 |   tenantId: string;
49 |   user: User;
50 |   role: string;
51 | }
52 | 
53 | export type {
54 |   Tenant,
55 |   UpdateTenant,
56 |   TenantUsageReport,
57 |   TokenReport,
58 |   TokenTypeMetrics,
59 |   TenantInvitation,
60 |   CreateTenantInvitation,
61 |   TenantMember,
62 |   User,
63 | };
64 | 


--------------------------------------------------------------------------------
/src/types/models/token-intents.ts:
--------------------------------------------------------------------------------
 1 | import type {
 2 |   TokenBase,
 3 |   DataObject,
 4 |   Auditable,
 5 |   TokenType,
 6 | } from '@/types/models';
 7 | 
 8 | interface TokenIntentCardDetails {
 9 |   type: 'card';
10 |   card: {
11 |     bin: string;
12 |     last4: string;
13 |     brand: string;
14 |     funding: string;
15 |     expirationMonth: number;
16 |     expirationYear: number;
17 |     authentication?: string;
18 |   };
19 | }
20 | 
21 | type TokenTypesForTokenIntents = Exclude<TokenType, 'token' | 'card'>;
22 | 
23 | type TokenTypeMap = {
24 |   [K in TokenTypesForTokenIntents]: {
25 |     type: K;
26 |   } & Record<K, Record<string, unknown>>;
27 | };
28 | 
29 | type TokenIntent<DataType = DataObject> = (TokenBase<DataType> &
30 |   Omit<Auditable, 'modifiedAt' | 'modifiedBy'> & {
31 |     id: string;
32 |     tenantId: string;
33 |     expiresAt: string;
34 |     fingerprint?: string;
35 |     _debug?: Record<string, unknown>;
36 |   }) &
37 |   (
38 |     | TokenTypeMap[TokenTypesForTokenIntents]
39 |     | TokenIntentCardDetails
40 |     | {
41 |         type: 'token';
42 |       }
43 |   );
44 | 
45 | type CreateTokenIntent<DataType = DataObject> = Pick<
46 |   TokenIntent<DataType>,
47 |   'type' | 'data'
48 | >;
49 | 
50 | export type { TokenIntent, CreateTokenIntent, TokenIntentCardDetails };
51 | 


--------------------------------------------------------------------------------
/src/types/models/tokenize.ts:
--------------------------------------------------------------------------------
 1 | import type { Primitive } from './shared';
 2 | 
 3 | type TokenizeObject<DataType = Primitive> = {
 4 |   [key: string]:
 5 |     | Primitive
 6 |     | TokenizeObject<DataType>
 7 |     | TokenizeArray<DataType>
 8 |     | DataType;
 9 | };
10 | type TokenizeArray<DataType = Primitive> = Array<
11 |   Primitive | TokenizeObject<DataType> | TokenizeArray<DataType> | DataType
12 | >;
13 | type TokenizeData<DataType = Primitive> =
14 |   | TokenizeArray<DataType>
15 |   | (TokenizeObject<DataType> & {
16 |       _debug?: Record<string, unknown>;
17 |     });
18 | 
19 | export type { TokenizeObject, TokenizeArray, TokenizeData };
20 | 


--------------------------------------------------------------------------------
/src/types/models/tokens.ts:
--------------------------------------------------------------------------------
  1 | import type { BinDetails } from './bin-details';
  2 | import { CardDetails } from './card-details';
  3 | import type { Primitive, TokenBase } from './shared';
  4 | 
  5 | const DATA_CLASSIFICATIONS = ['general', 'bank', 'pci', 'pii'] as const;
  6 | 
  7 | type DataClassification = typeof DATA_CLASSIFICATIONS[number];
  8 | 
  9 | const DATA_IMPACT_LEVELS = ['low', 'moderate', 'high'] as const;
 10 | 
 11 | type DataImpactLevel = typeof DATA_IMPACT_LEVELS[number];
 12 | 
 13 | const DATA_RESTRICTION_POLICIES = ['mask', 'redact'] as const;
 14 | 
 15 | type DataRestrictionPolicy = typeof DATA_RESTRICTION_POLICIES[number];
 16 | 
 17 | type MaskObject = {
 18 |   [member: string]: TokenMask;
 19 | };
 20 | type MaskArray = Array<TokenMask>;
 21 | type TokenMask = string | null | MaskObject | MaskArray;
 22 | 
 23 | interface TokenEncryptionKey {
 24 |   key: string;
 25 |   alg: string;
 26 | }
 27 | 
 28 | interface TokenEncryption {
 29 |   cek: TokenEncryptionKey;
 30 |   kek: TokenEncryptionKey;
 31 | }
 32 | 
 33 | interface TokenPrivacy {
 34 |   classification?: DataClassification;
 35 |   impactLevel?: DataImpactLevel;
 36 |   restrictionPolicy?: DataRestrictionPolicy;
 37 | }
 38 | 
 39 | interface TokenEnrichments {
 40 |   binDetails?: BinDetails;
 41 |   cardDetails?: CardDetails;
 42 | }
 43 | 
 44 | type Token<DataType = Primitive> = TokenBase<DataType> & {
 45 |   id: string;
 46 |   privacy?: TokenPrivacy;
 47 |   containers?: string[];
 48 |   encryption?: TokenEncryption;
 49 |   searchIndexes?: string[];
 50 |   fingerprintExpression?: string;
 51 |   mask?: TokenMask;
 52 |   expiresAt?: string;
 53 |   enrichments?: TokenEnrichments;
 54 |   tenantId: string;
 55 |   fingerprint?: string;
 56 |   metadata?: Record<string, string>;
 57 |   _debug?: Record<string, unknown>;
 58 | };
 59 | 
 60 | type CreateToken<DataType = Primitive> = Pick<
 61 |   Token<DataType>,
 62 |   | 'type'
 63 |   | 'data'
 64 |   | 'privacy'
 65 |   | 'containers'
 66 |   | 'metadata'
 67 |   | 'encryption'
 68 |   | 'searchIndexes'
 69 |   | 'fingerprintExpression'
 70 |   | 'mask'
 71 |   | 'expiresAt'
 72 | > & {
 73 |   deduplicateToken?: boolean;
 74 |   id?: string;
 75 |   _debug?: Record<string, unknown>;
 76 | };
 77 | 
 78 | type UpdateToken<DataType = Primitive> = Partial<
 79 |   Pick<
 80 |     Token<DataType>,
 81 |     | 'data'
 82 |     | 'containers'
 83 |     | 'metadata'
 84 |     | 'encryption'
 85 |     | 'searchIndexes'
 86 |     | 'fingerprintExpression'
 87 |     | 'mask'
 88 |     | 'expiresAt'
 89 |   > & {
 90 |     privacy: Omit<TokenPrivacy, 'classification'>;
 91 |     deduplicateToken: boolean;
 92 |     _debug?: Record<string, unknown>;
 93 |   }
 94 | >;
 95 | 
 96 | export type {
 97 |   Token,
 98 |   TokenEnrichments,
 99 |   CreateToken,
100 |   UpdateToken,
101 |   DataClassification,
102 |   DataImpactLevel,
103 |   DataRestrictionPolicy,
104 | };
105 | 
106 | export { DATA_CLASSIFICATIONS, DATA_IMPACT_LEVELS, DATA_RESTRICTION_POLICIES };
107 | 


--------------------------------------------------------------------------------
/src/types/models/util.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Make all properties in T nullable
 3 |  */
 4 | type Nullable<T> = {
 5 |   [P in keyof T]: T[P] | null;
 6 | };
 7 | 
 8 | /**
 9 |  * Make selected properties in T nullable
10 |  */
11 | type NullableProps<T, K extends keyof T> = T | Nullable<Pick<T, K>>;
12 | 
13 | export type { Nullable, NullableProps };
14 | 


--------------------------------------------------------------------------------
/src/types/sdk/index.ts:
--------------------------------------------------------------------------------
1 | export * from './sdk';
2 | export * from './services';
3 | 


--------------------------------------------------------------------------------
/src/types/sdk/sdk.ts:
--------------------------------------------------------------------------------
  1 | import type { BasisTheoryElements } from '@/types/elements';
  2 | import type {
  3 |   Applications,
  4 |   ApplicationTemplates,
  5 |   HttpClient,
  6 |   Logs,
  7 |   Permissions,
  8 |   Proxies,
  9 |   Proxy,
 10 |   ReactorFormulas,
 11 |   Reactors,
 12 |   Sessions,
 13 |   Tenants,
 14 |   Tokenize,
 15 |   Tokens,
 16 |   ThreeDS,
 17 |   TokenIntents,
 18 | } from './services';
 19 | import { ApplicationKeys } from './services/applicationKeys';
 20 | 
 21 | interface ApplicationInfo {
 22 |   name?: string;
 23 |   version?: string;
 24 |   url?: string;
 25 | }
 26 | 
 27 | interface BasisTheoryInitOptions {
 28 |   apiBaseUrl?: string;
 29 |   appInfo?: ApplicationInfo;
 30 |   disableTelemetry?: boolean;
 31 |   debug?: boolean;
 32 | }
 33 | 
 34 | interface BasisTheoryInitOptionsWithoutElements extends BasisTheoryInitOptions {
 35 |   elements?: false;
 36 | }
 37 | 
 38 | interface BasisTheoryInitOptionsWithElements extends BasisTheoryInitOptions {
 39 |   elements: true;
 40 |   elementsBaseUrl?: string;
 41 |   elementsClientUrl?: string;
 42 |   elementsUseNgApi?: boolean;
 43 |   elementsUseSameOriginApi?: boolean;
 44 | }
 45 | 
 46 | interface BasisTheoryInit {
 47 |   init(
 48 |     apiKey: string,
 49 |     options?: BasisTheoryInitOptionsWithoutElements
 50 |   ): Promise<BasisTheory>;
 51 | 
 52 |   init(
 53 |     apiKey: string,
 54 |     options: BasisTheoryInitOptionsWithElements
 55 |   ): Promise<BasisTheory & BasisTheoryElements>;
 56 | }
 57 | interface BasisTheory extends Tokenize {
 58 |   applications: Applications;
 59 |   applicationKeys: ApplicationKeys;
 60 |   applicationTemplates: ApplicationTemplates;
 61 |   /**
 62 |    * @description Allows you to utilize element values in requests to a third-party API using our HTTP client service.
 63 |    * @requires Before proceeding, ensure that the elements are properly initialized. Refer to the [Basis Theory Docs - Initialize elements]((https://developers.basistheory.com/docs/sdks/web/javascript/#initialization)) for more information.
 64 |    * @see For details on how to use the HTTP client service, refer to [Basis Theory Docs - HTTP Client](https://developers.basistheory.com/docs/sdks/web/javascript/methods#http-client-service).
 65 |    */
 66 |   client?: HttpClient;
 67 |   logs: Logs;
 68 |   permissions: Permissions;
 69 |   proxies: Proxies;
 70 |   proxy: Proxy;
 71 |   reactorFormulas: ReactorFormulas;
 72 |   reactors: Reactors;
 73 |   sessions: Sessions;
 74 |   tenants: Tenants;
 75 |   tokens: Tokens;
 76 |   threeds: ThreeDS;
 77 |   tokenIntents: TokenIntents;
 78 | }
 79 | 
 80 | interface ClientUserAgent {
 81 |   client: string;
 82 |   clientVersion: string;
 83 |   osVersion: string;
 84 |   runtimeVersion: string;
 85 |   application?: ApplicationInfo;
 86 | }
 87 | 
 88 | type BasisTheoryServices = keyof Omit<BasisTheory, 'client'>;
 89 | 
 90 | type BasisTheoryServicesBasePathMap = {
 91 |   [key in BasisTheoryServices]: string;
 92 | };
 93 | 
 94 | type BasisTheoryInitStatus = 'not-started' | 'in-progress' | 'done' | 'error';
 95 | 
 96 | export type {
 97 |   ApplicationInfo,
 98 |   BasisTheoryInitStatus,
 99 |   BasisTheoryInit,
100 |   BasisTheory,
101 |   BasisTheoryInitOptionsWithoutElements,
102 |   BasisTheoryInitOptionsWithElements,
103 |   BasisTheoryInitOptions,
104 |   BasisTheoryServicesBasePathMap,
105 |   ClientUserAgent,
106 | };
107 | 


--------------------------------------------------------------------------------
/src/types/sdk/services/application-templates.ts:
--------------------------------------------------------------------------------
1 | import type { ApplicationTemplate } from '@/types/models/application-templates';
2 | import type { RequestOptions, Retrieve } from './shared';
3 | 
4 | interface ApplicationTemplates extends Retrieve<ApplicationTemplate> {
5 |   list(options?: RequestOptions): Promise<ApplicationTemplate[]>;
6 | }
7 | 
8 | export type { ApplicationTemplates };
9 | 


--------------------------------------------------------------------------------
/src/types/sdk/services/applicationKeys.ts:
--------------------------------------------------------------------------------
 1 | import type { ApplicationKey } from '@/types/models';
 2 | 
 3 | interface ApplicationKeys {
 4 |   create(id: string): Promise<ApplicationKey>;
 5 |   delete(applicationId: string, keyId: string): Promise<void>;
 6 |   get(applicationId: string): Promise<ApplicationKey[]>;
 7 |   getById(applicationId: string, keyId: string): Promise<ApplicationKey>;
 8 | }
 9 | 
10 | export type { ApplicationKeys };
11 | 


--------------------------------------------------------------------------------
/src/types/sdk/services/applications.ts:
--------------------------------------------------------------------------------
 1 | import type {
 2 |   Application,
 3 |   CreateApplication,
 4 |   UpdateApplication,
 5 | } from '@/types/models';
 6 | import type {
 7 |   Create,
 8 |   Delete,
 9 |   List,
10 |   PaginatedQuery,
11 |   RequestOptions,
12 |   Retrieve,
13 |   Update,
14 | } from './shared';
15 | 
16 | interface ListApplicationsQuery extends PaginatedQuery {
17 |   id?: string | string[];
18 | }
19 | 
20 | interface Applications
21 |   extends Create<Application, CreateApplication>,
22 |     Retrieve<Application>,
23 |     Update<Application, UpdateApplication>,
24 |     Delete,
25 |     List<Application, ListApplicationsQuery> {
26 |   retrieveByKey(options?: RequestOptions): Promise<Application>;
27 |   regenerateKey(id: string, options?: RequestOptions): Promise<Application>;
28 | }
29 | 
30 | export type { Applications, ListApplicationsQuery };
31 | 


--------------------------------------------------------------------------------
/src/types/sdk/services/http.ts:
--------------------------------------------------------------------------------
 1 | interface RequestConfig {
 2 |   headers?: Record<string, string>;
 3 | }
 4 | 
 5 | interface HttpClient {
 6 |   post(url: string, payload: unknown, config?: RequestConfig): Promise<unknown>;
 7 |   put(url: string, payload: unknown, config?: RequestConfig): Promise<unknown>;
 8 |   patch(
 9 |     url: string,
10 |     payload: unknown,
11 |     config?: RequestConfig
12 |   ): Promise<unknown>;
13 |   get(url: string, config?: RequestConfig): Promise<unknown>;
14 |   delete(url: string, config?: RequestConfig): Promise<unknown>;
15 | }
16 | 
17 | export type { HttpClient, RequestConfig };
18 | 


--------------------------------------------------------------------------------
/src/types/sdk/services/index.ts:
--------------------------------------------------------------------------------
 1 | export * from './shared';
 2 | export * from './tokens';
 3 | export * from './tokenize';
 4 | export * from './applications';
 5 | export * from './applicationKeys';
 6 | export * from './tenants';
 7 | export * from './logs';
 8 | export * from './reactor-formulas';
 9 | export * from './reactors';
10 | export * from './permissions';
11 | export * from './proxies';
12 | export * from './proxy';
13 | export * from './sessions';
14 | export * from './http';
15 | export * from './application-templates';
16 | export * from './threeds';
17 | export * from './token-intents';
18 | 


--------------------------------------------------------------------------------
/src/types/sdk/services/logs.ts:
--------------------------------------------------------------------------------
 1 | import type { Log } from '@/types/models';
 2 | import type { List, PaginatedQuery } from './shared';
 3 | 
 4 | interface ListLogQuery extends PaginatedQuery {
 5 |   entityType?: string;
 6 |   entityId?: string;
 7 |   startDate?: string;
 8 |   endDate?: string;
 9 | }
10 | 
11 | type Logs = List<Log, ListLogQuery>;
12 | 
13 | export type { ListLogQuery, Logs };
14 | 


--------------------------------------------------------------------------------
/src/types/sdk/services/permissions.ts:
--------------------------------------------------------------------------------
 1 | import type { Permission } from '@/types/models';
 2 | import { ApplicationType } from '@/types/models';
 3 | import type { RequestOptions } from './shared';
 4 | 
 5 | interface ListPermissionsQuery {
 6 |   applicationType?: ApplicationType;
 7 | }
 8 | 
 9 | interface Permissions {
10 |   list(
11 |     query?: ListPermissionsQuery,
12 |     options?: RequestOptions
13 |   ): Promise<Permission[]>;
14 | }
15 | 
16 | export type { Permissions, ListPermissionsQuery };
17 | 


--------------------------------------------------------------------------------
/src/types/sdk/services/proxies.ts:
--------------------------------------------------------------------------------
 1 | import type {
 2 |   CreateProxy,
 3 |   PatchProxy,
 4 |   Proxy,
 5 |   UpdateProxy,
 6 | } from '@/types/models/proxies';
 7 | import type {
 8 |   Create,
 9 |   Delete,
10 |   List,
11 |   PaginatedQuery,
12 |   Retrieve,
13 |   Update,
14 |   Patch,
15 | } from '@/types/sdk';
16 | 
17 | interface ListProxyQuery extends PaginatedQuery {
18 |   id?: string | string[];
19 |   name?: string;
20 | }
21 | 
22 | interface Proxies
23 |   extends Create<Proxy, CreateProxy>,
24 |     Retrieve<Proxy>,
25 |     Update<Proxy, UpdateProxy>,
26 |     Patch<PatchProxy>,
27 |     Delete,
28 |     List<Proxy, ListProxyQuery> {}
29 | 
30 | export type { Proxies, ListProxyQuery };
31 | 


--------------------------------------------------------------------------------
/src/types/sdk/services/proxy.ts:
--------------------------------------------------------------------------------
 1 | import type { RequestOptions } from './shared';
 2 | 
 3 | interface Proxy {
 4 |   get(options?: ProxyRequestOptions): Promise<any>;
 5 |   post(options?: ProxyRequestOptions): Promise<any>;
 6 |   patch(options?: ProxyRequestOptions): Promise<any>;
 7 |   put(options?: ProxyRequestOptions): Promise<any>;
 8 |   delete(options?: ProxyRequestOptions): Promise<any>;
 9 | }
10 | 
11 | type BasisTheoryProxyHeaders = {
12 |   [key: string]: string;
13 |   'BT-PROXY-URL': string;
14 |   'BT-PROXY-KEY': string;
15 | };
16 | 
17 | type ProxyHeaders = Partial<BasisTheoryProxyHeaders>;
18 | 
19 | type BasisTheoryQueryParams = {
20 |   [key: string]: string;
21 |   'bt-proxy-key': string;
22 | };
23 | 
24 | type ProxyQuery = Partial<BasisTheoryQueryParams>;
25 | 
26 | interface ProxyRequestOptions extends RequestOptions {
27 |   includeResponseHeaders?: boolean;
28 |   path?: string;
29 |   query?: ProxyQuery;
30 |   headers?: ProxyHeaders;
31 |   body?: unknown;
32 | }
33 | 
34 | export type { Proxy, ProxyRequestOptions, ProxyHeaders, ProxyQuery };
35 | 


--------------------------------------------------------------------------------
/src/types/sdk/services/reactor-formulas.ts:
--------------------------------------------------------------------------------
 1 | import type { CreateReactorFormula, ReactorFormula } from '@/types/models';
 2 | import type {
 3 |   Create,
 4 |   Delete,
 5 |   List,
 6 |   PaginatedQuery,
 7 |   Retrieve,
 8 |   Update,
 9 | } from './shared';
10 | 
11 | /**
12 |  * @deprecated Reactor Formulas are now deprecated and will be removed in a future release.
13 |  * @description We have introduced a `code` property for Reactors to replace Formula's code. For more details visit [our API reference](https://developers.basistheory.com/docs/api/reactors#create-reactor).
14 |  */
15 | interface ListReactorFormulaQuery extends PaginatedQuery {
16 |   name?: string;
17 | }
18 | /**
19 |  * @deprecated Reactor Formulas are now deprecated and will be removed in a future release.
20 |  * @description We have introduced a `code` property for Reactors to replace Formula's code. For more details visit [our API reference](https://developers.basistheory.com/docs/api/reactors#create-reactor).
21 |  */
22 | interface ReactorFormulas
23 |   extends Create<ReactorFormula, CreateReactorFormula>,
24 |     Retrieve<ReactorFormula>,
25 |     Update<ReactorFormula, CreateReactorFormula>,
26 |     Delete,
27 |     List<ReactorFormula, ListReactorFormulaQuery> {}
28 | 
29 | export type { ListReactorFormulaQuery, ReactorFormulas };
30 | 


--------------------------------------------------------------------------------
/src/types/sdk/services/reactors.ts:
--------------------------------------------------------------------------------
 1 | import type {
 2 |   CreateReactor,
 3 |   UpdateReactor,
 4 |   Reactor,
 5 |   DataObject,
 6 |   ReactResponse,
 7 |   PatchReactor,
 8 | } from '@/types/models';
 9 | import type {
10 |   Create,
11 |   Delete,
12 |   List,
13 |   PaginatedQuery,
14 |   Retrieve,
15 |   Update,
16 |   Patch,
17 |   RequestOptions,
18 | } from './shared';
19 | 
20 | interface ListReactorQuery extends PaginatedQuery {
21 |   id?: string | string[];
22 |   name?: string;
23 | }
24 | 
25 | interface ReactRequest {
26 |   args: DataObject;
27 |   callbackUrl?: string;
28 |   timeoutMs?: number;
29 | }
30 | 
31 | interface Reactors
32 |   extends Create<Reactor, CreateReactor>,
33 |     Retrieve<Reactor>,
34 |     Update<Reactor, UpdateReactor>,
35 |     Patch<PatchReactor>,
36 |     Delete,
37 |     List<Reactor, ListReactorQuery> {
38 |   react(
39 |     reactorId: string,
40 |     request: ReactRequest,
41 |     options?: RequestOptions
42 |   ): Promise<ReactResponse>;
43 | }
44 | 
45 | export type { ListReactorQuery, Reactors, ReactRequest };
46 | 


--------------------------------------------------------------------------------
/src/types/sdk/services/sessions.ts:
--------------------------------------------------------------------------------
 1 | import type { AccessRule } from '@/types/models/applications';
 2 | import type { RequestOptions } from '@/types/sdk';
 3 | 
 4 | type AuthorizeSessionRequest = {
 5 |   nonce: string;
 6 |   expiresAt?: string;
 7 |   permissions?: string[];
 8 |   rules?: AccessRule[];
 9 | };
10 | 
11 | type CreateSessionResponse = {
12 |   sessionKey: string;
13 |   nonce: string;
14 |   expiresAt: string;
15 |   _debug?: Record<string, unknown>;
16 | };
17 | 
18 | interface Sessions {
19 |   create(options?: RequestOptions): Promise<CreateSessionResponse>;
20 |   authorize(
21 |     authorizeSessionRequest: AuthorizeSessionRequest,
22 |     options?: RequestOptions
23 |   ): Promise<void>;
24 | }
25 | 
26 | export { AuthorizeSessionRequest, CreateSessionResponse, Sessions };
27 | 


--------------------------------------------------------------------------------
/src/types/sdk/services/shared.ts:
--------------------------------------------------------------------------------
 1 | interface RequestOptions {
 2 |   apiKey?: string;
 3 |   correlationId?: string;
 4 |   idempotencyKey?: string;
 5 | }
 6 | 
 7 | type QueryValue =
 8 |   | boolean
 9 |   | number
10 |   | string
11 |   | null
12 |   | undefined
13 |   | Record<string, string>
14 |   | (number | string)[];
15 | 
16 | interface PaginatedQuery {
17 |   [key: string]: QueryValue;
18 |   [key: number]: QueryValue;
19 |   page?: number;
20 |   size?: number;
21 |   start?: string;
22 | }
23 | interface PaginatedList<T> {
24 |   pagination: {
25 |     totalItems?: number;
26 |     pageNumber?: number;
27 |     pageSize: number;
28 |     totalPages?: number;
29 |     after?: string;
30 |   };
31 |   data: T[];
32 | }
33 | 
34 | type Create<T, C> = {
35 |   create(model: C, options?: RequestOptions): Promise<T>;
36 | };
37 | 
38 | type Retrieve<T> = {
39 |   retrieve(id: string, options?: RequestOptions): Promise<T>;
40 | };
41 | 
42 | type Update<T, U> = {
43 |   update(id: string, model: U, options?: RequestOptions): Promise<T>;
44 | };
45 | 
46 | type Patch<P> = {
47 |   patch(id: string, model: P, options?: RequestOptions): Promise<void>;
48 | };
49 | 
50 | type Delete = {
51 |   delete(id: string, options?: RequestOptions): Promise<void>;
52 | };
53 | 
54 | type List<T, Q extends PaginatedQuery = PaginatedQuery> = {
55 |   list(query?: Q, options?: RequestOptions): Promise<PaginatedList<T>>;
56 | };
57 | 
58 | export type {
59 |   RequestOptions,
60 |   PaginatedQuery,
61 |   PaginatedList,
62 |   Create,
63 |   Retrieve,
64 |   Update,
65 |   Delete,
66 |   List,
67 |   Patch,
68 | };
69 | 


--------------------------------------------------------------------------------
/src/types/sdk/services/tenants.ts:
--------------------------------------------------------------------------------
 1 | import type {
 2 |   CreateTenantInvitation,
 3 |   Tenant,
 4 |   TenantInvitation,
 5 |   TenantMember,
 6 |   TenantUsageReport,
 7 |   UpdateTenant,
 8 | } from '@/types/models';
 9 | import type { PaginatedList, RequestOptions } from './shared';
10 | import { PaginatedQuery } from './shared';
11 | 
12 | interface ListTenantInvitationsQuery extends PaginatedQuery {
13 |   status?: 'PENDING' | 'EXPIRED';
14 | }
15 | 
16 | interface ListTenantMembersQuery extends PaginatedQuery {
17 |   userId?: string | string[];
18 | }
19 | 
20 | interface Tenants {
21 |   retrieve(options?: RequestOptions): Promise<Tenant>;
22 |   update(model: UpdateTenant, options?: RequestOptions): Promise<Tenant>;
23 |   delete(options?: RequestOptions): Promise<void>;
24 |   retrieveUsageReport(options?: RequestOptions): Promise<TenantUsageReport>;
25 | 
26 |   createInvitation(
27 |     model: CreateTenantInvitation,
28 |     options?: RequestOptions
29 |   ): Promise<TenantInvitation>;
30 |   resendInvitation(
31 |     invitationId: string,
32 |     options?: RequestOptions
33 |   ): Promise<TenantInvitation>;
34 |   listInvitations(
35 |     query?: ListTenantInvitationsQuery,
36 |     options?: RequestOptions
37 |   ): Promise<PaginatedList<TenantInvitation>>;
38 |   retrieveInvitation(
39 |     invitationId: string,
40 |     options?: RequestOptions
41 |   ): Promise<TenantInvitation>;
42 |   deleteInvitation(
43 |     invitationId: string,
44 |     options?: RequestOptions
45 |   ): Promise<void>;
46 | 
47 |   listMembers(
48 |     query?: ListTenantMembersQuery,
49 |     options?: RequestOptions
50 |   ): Promise<PaginatedList<TenantMember>>;
51 |   deleteMember(memberId: string, options?: RequestOptions): Promise<void>;
52 | }
53 | 
54 | export type { Tenants, ListTenantInvitationsQuery, ListTenantMembersQuery };
55 | 


--------------------------------------------------------------------------------
/src/types/sdk/services/threeds.ts:
--------------------------------------------------------------------------------
 1 | import {
 2 |   AuthenticateThreeDSSessionRequest,
 3 |   CreateThreeDSSessionRequest,
 4 |   CreateThreeDSSessionResponse,
 5 |   ThreeDSAuthentication,
 6 |   ThreeDSSession,
 7 | } from '@/types/models/threeds';
 8 | 
 9 | interface ThreeDS {
10 |   createSession(
11 |     createRequest: CreateThreeDSSessionRequest
12 |   ): Promise<CreateThreeDSSessionResponse>;
13 |   getSessionById(sessionId: string): Promise<ThreeDSSession>;
14 |   authenticateSession(
15 |     sessionId: string,
16 |     authenticateRequest: AuthenticateThreeDSSessionRequest
17 |   ): Promise<ThreeDSAuthentication>;
18 |   getChallengeResult(sessionId: string): Promise<ThreeDSAuthentication>;
19 | }
20 | 
21 | export type { ThreeDS };
22 | 


--------------------------------------------------------------------------------
/src/types/sdk/services/token-intents.ts:
--------------------------------------------------------------------------------
1 | import type { TokenIntent, CreateTokenIntent } from '@/types/models';
2 | import type { Create, Delete } from './shared';
3 | 
4 | interface TokenIntents extends Create<TokenIntent, CreateTokenIntent>, Delete {}
5 | 
6 | export type { TokenIntents };
7 | 


--------------------------------------------------------------------------------
/src/types/sdk/services/tokenize.ts:
--------------------------------------------------------------------------------
 1 | import type { TokenizeData } from '@/types/models';
 2 | import type { RequestOptions } from './shared';
 3 | 
 4 | interface Tokenize {
 5 |   tokenize(
 6 |     tokens: TokenizeData,
 7 |     options?: RequestOptions
 8 |   ): Promise<TokenizeData>;
 9 | }
10 | 
11 | export type { Tokenize };
12 | 


--------------------------------------------------------------------------------
/src/types/sdk/services/tokens.ts:
--------------------------------------------------------------------------------
 1 | import type {
 2 |   Token,
 3 |   CreateToken,
 4 |   TokenType,
 5 |   UpdateToken,
 6 | } from '@/types/models';
 7 | import type {
 8 |   Create,
 9 |   Retrieve,
10 |   Delete,
11 |   List,
12 |   RequestOptions,
13 |   PaginatedQuery,
14 |   PaginatedList,
15 |   Update,
16 | } from './shared';
17 | 
18 | interface ListTokensQuery extends PaginatedQuery {
19 |   id?: string | string[];
20 |   type?: TokenType | TokenType[];
21 |   metadata?: Record<string, string>;
22 | }
23 | 
24 | interface SearchTokensRequest {
25 |   query?: string;
26 |   page?: number;
27 |   size?: number;
28 | }
29 | 
30 | interface Tokens
31 |   extends Create<Token, CreateToken>,
32 |     Update<Token, UpdateToken>,
33 |     // avoid casting when accessing token data props
34 |     // eslint-disable-next-line @typescript-eslint/no-explicit-any
35 |     Retrieve<Token<any>>,
36 |     Delete,
37 |     List<Token, ListTokensQuery> {
38 |   search(
39 |     searchRequest: SearchTokensRequest,
40 |     options?: RequestOptions
41 |   ): Promise<PaginatedList<Token>>;
42 | }
43 | 
44 | export type { Tokens, ListTokensQuery, SearchTokensRequest };
45 | 


--------------------------------------------------------------------------------
/test/application-templates.test.ts:
--------------------------------------------------------------------------------
  1 | import type MockAdapter from 'axios-mock-adapter';
  2 | import { Chance } from 'chance';
  3 | import { BasisTheory } from '@/BasisTheory';
  4 | import {
  5 |   API_KEY_HEADER,
  6 |   BT_IDEMPOTENCY_KEY_HEADER,
  7 |   BT_TRACE_ID_HEADER,
  8 | } from '@/common';
  9 | import type { BasisTheory as IBasisTheory } from '@/types/sdk';
 10 | import {
 11 |   errorStatus,
 12 |   expectBasisTheoryApiError,
 13 |   mockServiceClient,
 14 |   testRetrieve,
 15 | } from './setup/utils';
 16 | 
 17 | describe('Application Templates', () => {
 18 |   let bt: IBasisTheory,
 19 |     chance: Chance.Chance,
 20 |     apiKey: string,
 21 |     client: MockAdapter;
 22 | 
 23 |   beforeAll(async () => {
 24 |     chance = new Chance();
 25 |     apiKey = chance.string();
 26 |     bt = await new BasisTheory().init(apiKey);
 27 |     client = mockServiceClient(bt.applicationTemplates);
 28 |   });
 29 |   beforeEach(() => {
 30 |     client.resetHandlers();
 31 |     client.resetHistory();
 32 |   });
 33 | 
 34 |   describe('list', () => {
 35 |     test('should list', async () => {
 36 |       const id = chance.string();
 37 |       const applicationType = chance.string();
 38 |       const templateType = chance.string();
 39 | 
 40 |       client.onGet('/').reply(
 41 |         200,
 42 |         JSON.stringify([
 43 |           {
 44 |             id,
 45 |             application_type: applicationType,
 46 |             template_type: templateType,
 47 |           },
 48 |         ])
 49 |       );
 50 | 
 51 |       expect(await bt.applicationTemplates.list()).toStrictEqual([
 52 |         {
 53 |           id,
 54 |           applicationType,
 55 |           templateType,
 56 |         },
 57 |       ]);
 58 |       expect(client.history.get).toHaveLength(1);
 59 |       expect(client.history.get[0].headers).toMatchObject({
 60 |         [API_KEY_HEADER]: apiKey,
 61 |       });
 62 |     });
 63 |     test('should list with options', async () => {
 64 |       const id = chance.string();
 65 |       const applicationType = chance.string();
 66 |       const templateType = chance.string();
 67 |       const _apiKey = chance.string();
 68 |       const correlationId = chance.string();
 69 |       const idempotencyKey = chance.string();
 70 | 
 71 |       client.onGet('/').reply(
 72 |         200,
 73 |         JSON.stringify([
 74 |           {
 75 |             id,
 76 |             application_type: applicationType,
 77 |             template_type: templateType,
 78 |           },
 79 |         ])
 80 |       );
 81 | 
 82 |       expect(
 83 |         await bt.applicationTemplates.list({
 84 |           apiKey: _apiKey,
 85 |           correlationId,
 86 |           idempotencyKey,
 87 |         })
 88 |       );
 89 |       expect(client.history.get).toHaveLength(1);
 90 |       expect(client.history.get[0].headers).toMatchObject({
 91 |         [API_KEY_HEADER]: _apiKey,
 92 |         [BT_TRACE_ID_HEADER]: correlationId,
 93 |         [BT_IDEMPOTENCY_KEY_HEADER]: idempotencyKey,
 94 |       });
 95 |     });
 96 |     test('should reject with status >= 400 <= 599', async () => {
 97 |       const status = errorStatus();
 98 | 
 99 |       client.onGet('/').reply(status);
100 | 
101 |       const promise = bt.applicationTemplates.list();
102 | 
103 |       await expectBasisTheoryApiError(promise, status);
104 |     });
105 |   });
106 | 
107 |   describe('retrieve', () => {
108 |     testRetrieve(() => ({
109 |       service: bt.applicationTemplates,
110 |       client,
111 |     }));
112 |   });
113 | });
114 | 


--------------------------------------------------------------------------------
/test/elements/create.test.ts:
--------------------------------------------------------------------------------
 1 | import { Chance } from 'chance';
 2 | import type { BasisTheoryElements } from '@/types/elements';
 3 | import type { BasisTheoryInit } from '@/types/sdk';
 4 | import { BasisTheory } from '../../src';
 5 | import { loadElements } from '../../src/elements';
 6 | 
 7 | jest.mock('../../src/elements/load');
 8 | 
 9 | describe('createElement', () => {
10 |   let bt: BasisTheoryElements & BasisTheoryInit, chance: Chance.Chance;
11 | 
12 |   beforeEach(() => {
13 |     bt = new BasisTheory();
14 |     chance = new Chance();
15 |   });
16 | 
17 |   describe('should throw error', () => {
18 |     test('when BT has not been initialized', () => {
19 |       expect(() => bt.createElement('card')).toThrow(
20 |         'BasisTheory Elements was not properly initialized.'
21 |       );
22 |       expect(loadElements).toHaveBeenCalledTimes(0);
23 |     });
24 |     test('when BT was initialized without elements:true', async () => {
25 |       await bt.init(chance.string());
26 |       expect(() => bt.createElement('card')).toThrow(
27 |         'BasisTheory Elements was not properly initialized.'
28 |       );
29 |       expect(loadElements).toHaveBeenCalledTimes(0);
30 |     });
31 |   });
32 | 
33 |   describe('when BT was initialized with elements:true', () => {
34 |     test('should delegate to elements instance', async () => {
35 |       const createElement = jest.fn();
36 |       const elements = ({
37 |         createElement,
38 |       } as unknown) as BasisTheoryElements;
39 | 
40 |       // eslint-disable-next-line jest/prefer-spy-on, @typescript-eslint/no-explicit-any
41 |       (elements as any).init = jest.fn().mockResolvedValueOnce(elements);
42 | 
43 |       jest.mocked(loadElements).mockResolvedValueOnce(elements);
44 | 
45 |       await bt.init(chance.string(), { elements: true });
46 | 
47 |       const type = chance.string() as 'card';
48 |       const options = {
49 |         [chance.string()]: chance.string(),
50 |       };
51 | 
52 |       bt.createElement(type, options);
53 | 
54 |       expect(createElement).toHaveBeenCalledWith(type, options);
55 |     });
56 |   });
57 | });
58 | 


--------------------------------------------------------------------------------
/test/elements/httpClient.test.ts:
--------------------------------------------------------------------------------
  1 | import { Chance } from 'chance';
  2 | 
  3 | describe('elements http client requests with element payloads (post, put, patch, get, delete)', () => {
  4 |   const chance = new Chance();
  5 | 
  6 |   let mockPost: jest.Mock,
  7 |     mockPut: jest.Mock,
  8 |     mockPatch: jest.Mock,
  9 |     mockGet: jest.Mock,
 10 |     mockDelete: jest.Mock,
 11 |     mockPostResponse: string,
 12 |     mockPutResponse: string,
 13 |     mockPatchResponse: string,
 14 |     expectationsMap: any,
 15 |     elements: any;
 16 | 
 17 |   afterEach(() => {
 18 |     jest.resetModules();
 19 |     jest.clearAllMocks();
 20 |   });
 21 | 
 22 |   beforeEach(async () => {
 23 |     mockPostResponse = chance.string();
 24 |     mockPutResponse = chance.string();
 25 |     mockPatchResponse = chance.string();
 26 | 
 27 |     mockPost = jest.fn().mockResolvedValue(mockPostResponse);
 28 |     mockPut = jest.fn().mockResolvedValue(mockPutResponse);
 29 |     mockPatch = jest.fn().mockResolvedValue(mockPatchResponse);
 30 |     mockGet = jest.fn();
 31 |     mockDelete = jest.fn();
 32 | 
 33 |     const elementsModule = (jest.requireActual(
 34 |       '@/elements'
 35 |     ) as unknown) as Record<string, unknown>;
 36 | 
 37 |     jest.mock('@/elements', () => ({
 38 |       ...elementsModule,
 39 |       loadElements: jest.fn().mockReturnValue({
 40 |         client: {
 41 |           post: mockPost,
 42 |           put: mockPut,
 43 |           patch: mockPatch,
 44 |           get: mockGet,
 45 |           delete: mockDelete,
 46 |         },
 47 |         init: jest.fn().mockResolvedValue({}),
 48 |         hasElement: jest.fn().mockReturnValue(true),
 49 |       }),
 50 |     }));
 51 | 
 52 |     const { BasisTheory } = await import('@/BasisTheory');
 53 | 
 54 |     elements = await new BasisTheory().init(chance.string(), {
 55 |       elements: true,
 56 |     });
 57 | 
 58 |     expectationsMap = {
 59 |       post: {
 60 |         fn: mockPost,
 61 |         response: mockPostResponse,
 62 |       },
 63 |       put: {
 64 |         fn: mockPut,
 65 |         response: mockPutResponse,
 66 |       },
 67 |       patch: {
 68 |         fn: mockPatch,
 69 |         response: mockPatchResponse,
 70 |       },
 71 |       get: {
 72 |         fn: mockGet,
 73 |       },
 74 |       delete: {
 75 |         fn: mockDelete,
 76 |       },
 77 |     };
 78 |   });
 79 | 
 80 |   test.each(['post', 'put', 'patch'])('calls %s', async (method) => {
 81 |     const expectedUrl = chance.url();
 82 |     const expectedPayload = {
 83 |       [chance.string()]: chance.string(),
 84 |     };
 85 |     const expectedConfig = {
 86 |       [chance.string()]: chance.string(),
 87 |     };
 88 | 
 89 |     const response = await elements.client[method](
 90 |       expectedUrl,
 91 |       expectedPayload,
 92 |       expectedConfig
 93 |     );
 94 | 
 95 |     expect(expectationsMap[method].fn).toHaveBeenCalledTimes(1);
 96 |     expect(expectationsMap[method].fn).toHaveBeenCalledWith(
 97 |       expectedUrl,
 98 |       expectedPayload,
 99 |       expectedConfig
100 |     );
101 |     expect(response).toStrictEqual(expectationsMap[method].response);
102 |   });
103 | 
104 |   test.each(['get', 'delete'])('calls %s', async (method) => {
105 |     const expectedUrl = chance.url();
106 | 
107 |     const expectedConfig = {
108 |       [chance.string()]: chance.string(),
109 |     };
110 | 
111 |     await elements.client[method](expectedUrl, expectedConfig);
112 | 
113 |     expect(expectationsMap[method].fn).toHaveBeenCalledTimes(1);
114 | 
115 |     expect(expectationsMap[method].fn).toHaveBeenCalledWith(
116 |       expectedUrl,
117 |       expectedConfig
118 |     );
119 |   });
120 | });
121 | 
122 | describe('http client error handling/warnings', () => {
123 |   const chance = new Chance();
124 | 
125 |   let BasisTheoryClient;
126 | 
127 |   afterEach(() => {
128 |     jest.resetModules();
129 |     jest.clearAllMocks();
130 |   });
131 | 
132 |   beforeEach(async () => {
133 |     const { BasisTheory } = await import('@/BasisTheory');
134 | 
135 |     BasisTheoryClient = BasisTheory;
136 |   });
137 | 
138 |   test('http client returns undefined when elements are not initialized', async () => {
139 |     const btClient = await new BasisTheoryClient().init(chance.string());
140 | 
141 |     expect(btClient.client).toBeUndefined();
142 |   });
143 | 
144 |   test('logs error to console when trying to use client with elements not initialized', async () => {
145 |     const consoleErrorMock = jest.spyOn(console, 'error');
146 | 
147 |     // eslint-disable-next-line @typescript-eslint/no-empty-function
148 |     consoleErrorMock.mockImplementation(() => {});
149 | 
150 |     const btClient = await new BasisTheoryClient().init(chance.string());
151 | 
152 |     expect(btClient.client).toBeUndefined();
153 | 
154 |     // eslint-disable-next-line no-console
155 |     expect(console.error).toHaveBeenCalledWith(
156 |       'Elements are not initialized. Either initialize elements or use a regular HTTP client if no elements are needed.'
157 |     );
158 | 
159 |     consoleErrorMock.mockRestore();
160 |   });
161 | });
162 | 


--------------------------------------------------------------------------------
/test/elements/tokenIntents.test.ts:
--------------------------------------------------------------------------------
1 | import { delegateTokenIntents } from '../../src/elements';
2 | import { testServiceDelegate } from '../setup/utils';
3 | 
4 | describe('elements token intents service', () => {
5 |   testServiceDelegate('tokenIntents', 'create', delegateTokenIntents);
6 | });
7 | 


--------------------------------------------------------------------------------
/test/elements/tokenize.test.ts:
--------------------------------------------------------------------------------
1 | import { delegateTokenize } from '../../src/elements';
2 | import { testMethodDelegate } from '../setup/utils';
3 | 
4 | describe('elements tokens service', () => {
5 |   testMethodDelegate('tokenize', delegateTokenize);
6 | });
7 | 


--------------------------------------------------------------------------------
/test/elements/tokens.test.ts:
--------------------------------------------------------------------------------
1 | import { delegateTokens } from '../../src/elements';
2 | import { testServiceDelegate } from '../setup/utils';
3 | 
4 | describe('elements tokens service', () => {
5 |   testServiceDelegate('tokens', 'create', delegateTokens);
6 | });
7 | 


--------------------------------------------------------------------------------
/test/init.test.ts:
--------------------------------------------------------------------------------
 1 | import { Chance } from 'chance';
 2 | import { BasisTheory } from '@/BasisTheory';
 3 | import {
 4 |   loadElements,
 5 |   delegateTokens,
 6 |   delegateTokenize,
 7 |   delegateProxy,
 8 |   delegateTokenIntents,
 9 | } from '@/elements';
10 | 
11 | jest.mock('../src/elements');
12 | 
13 | describe('Init', () => {
14 |   let chance: Chance.Chance;
15 | 
16 |   beforeEach(() => {
17 |     chance = new Chance();
18 |     (delegateTokens as jest.Mock).mockImplementation(() =>
19 |       jest.fn().mockReturnValue({})
20 |     );
21 |     (delegateTokenize as jest.Mock).mockImplementation(() =>
22 |       jest.fn().mockReturnValue({})
23 |     );
24 |     (delegateProxy as jest.Mock).mockImplementation(() =>
25 |       jest.fn().mockReturnValue({})
26 |     );
27 |     (delegateTokenIntents as jest.Mock).mockImplementation(() =>
28 |       jest.fn().mockReturnValue({})
29 |     );
30 |   });
31 | 
32 |   test('should throw error if init is called consecutively', () => {
33 |     const bt = new BasisTheory();
34 | 
35 |     bt.init(chance.string());
36 |     expect(() => bt.init(chance.string())).rejects.toThrow(
37 |       'This BasisTheory instance has been already initialized.'
38 |     );
39 |   });
40 | 
41 |   test('should throw error if await to init and call it again', async () => {
42 |     const bt = new BasisTheory();
43 | 
44 |     await bt.init(chance.string());
45 | 
46 |     await expect(() => bt.init(chance.string())).rejects.toThrow(
47 |       'This BasisTheory instance has been already initialized.'
48 |     );
49 |   });
50 | 
51 |   test('should throw error for invalid base API url', async () => {
52 |     const bt = new BasisTheory();
53 | 
54 |     await expect(() =>
55 |       bt.init(chance.string(), { apiBaseUrl: chance.string() })
56 |     ).rejects.toThrow('Invalid format for the given API base url.');
57 |   });
58 | 
59 |   test('should accept a valid base API url', async () => {
60 |     const bt = new BasisTheory();
61 |     const validUrl = chance.url({ protocol: 'https' });
62 | 
63 |     expect(
64 |       await bt.init(chance.string(), { apiBaseUrl: validUrl })
65 |     ).toStrictEqual(bt);
66 |   });
67 | 
68 |   test('should allow init again if throws error', async () => {
69 |     jest
70 |       .mocked(loadElements)
71 |       .mockRejectedValueOnce(new Error('Load Elements error'));
72 | 
73 |     const bt = new BasisTheory();
74 | 
75 |     await expect(() =>
76 |       bt.init(chance.string(), { elements: true })
77 |     ).rejects.toThrow('Load Elements error');
78 | 
79 |     expect(await bt.init(chance.string())).toStrictEqual(bt);
80 |   });
81 | });
82 | 


--------------------------------------------------------------------------------
/test/logs.test.ts:
--------------------------------------------------------------------------------
 1 | import MockAdapter from 'axios-mock-adapter';
 2 | import { Chance } from 'chance';
 3 | import { BasisTheory } from '@/BasisTheory';
 4 | import type { BasisTheory as IBasisTheory } from '@/types/sdk';
 5 | import { mockServiceClient, testCursorPaginatedList } from './setup/utils';
 6 | 
 7 | describe('Logs', () => {
 8 |   let bt: IBasisTheory,
 9 |     chance: Chance.Chance,
10 |     apiKey: string,
11 |     client: MockAdapter;
12 | 
13 |   beforeAll(async () => {
14 |     chance = new Chance();
15 |     apiKey = chance.string();
16 |     bt = await new BasisTheory().init(apiKey);
17 |     client = mockServiceClient(bt.logs);
18 |   });
19 | 
20 |   beforeEach(() => {
21 |     client.resetHandlers();
22 |     client.resetHistory();
23 |   });
24 | 
25 |   describe('List', () => {
26 |     testCursorPaginatedList(() => ({
27 |       service: bt.logs,
28 |       client,
29 |     }));
30 |   });
31 | });
32 | 


--------------------------------------------------------------------------------
/test/permissions.test.ts:
--------------------------------------------------------------------------------
  1 | import MockAdapter from 'axios-mock-adapter';
  2 | import { Chance } from 'chance';
  3 | import { BasisTheory } from '@/BasisTheory';
  4 | import {
  5 |   BT_TRACE_ID_HEADER,
  6 |   API_KEY_HEADER,
  7 |   BT_IDEMPOTENCY_KEY_HEADER,
  8 | } from '@/common';
  9 | import type { ApplicationType } from '@/types/models';
 10 | import type { BasisTheory as IBasisTheory } from '@/types/sdk';
 11 | import {
 12 |   errorStatus,
 13 |   expectBasisTheoryApiError,
 14 |   mockServiceClient,
 15 | } from './setup/utils';
 16 | 
 17 | describe('Permissions', () => {
 18 |   let bt: IBasisTheory,
 19 |     chance: Chance.Chance,
 20 |     apiKey: string,
 21 |     client: MockAdapter;
 22 | 
 23 |   beforeAll(async () => {
 24 |     chance = new Chance();
 25 |     apiKey = chance.string();
 26 |     bt = await new BasisTheory().init(apiKey);
 27 |     client = mockServiceClient(bt.permissions);
 28 |   });
 29 | 
 30 |   beforeEach(() => {
 31 |     client.resetHandlers();
 32 |     client.resetHistory();
 33 |   });
 34 | 
 35 |   describe('list permissions', () => {
 36 |     test('should list permissions', async () => {
 37 |       const type = chance.string();
 38 |       const description = chance.string();
 39 |       const applicationTypes = [chance.string() as ApplicationType];
 40 | 
 41 |       client.onGet().reply(
 42 |         200,
 43 |         JSON.stringify([
 44 |           {
 45 |             type,
 46 |             description,
 47 |             application_types: applicationTypes,
 48 |           },
 49 |         ])
 50 |       );
 51 | 
 52 |       expect(await bt.permissions.list()).toStrictEqual([
 53 |         {
 54 |           type,
 55 |           description,
 56 |           applicationTypes,
 57 |         },
 58 |       ]);
 59 | 
 60 |       expect(client.history.get).toHaveLength(1);
 61 |       expect(client.history.get[0].headers).toMatchObject({
 62 |         [API_KEY_HEADER]: apiKey,
 63 |       });
 64 |     });
 65 | 
 66 |     test('should list permissions w/ query', async () => {
 67 |       const type = chance.string();
 68 |       const description = chance.string();
 69 |       const applicationTypes = [
 70 |         chance.string({ alpha: true }) as ApplicationType,
 71 |       ];
 72 | 
 73 |       const query = {
 74 |         applicationType: applicationTypes[0],
 75 |       };
 76 |       const url = `/?application_type=${query.applicationType}`;
 77 | 
 78 |       client.onGet(url).reply(
 79 |         200,
 80 |         JSON.stringify([
 81 |           {
 82 |             type,
 83 |             description,
 84 |             application_types: applicationTypes,
 85 |           },
 86 |         ])
 87 |       );
 88 | 
 89 |       expect(await bt.permissions.list(query)).toStrictEqual([
 90 |         {
 91 |           type,
 92 |           description,
 93 |           applicationTypes,
 94 |         },
 95 |       ]);
 96 |       expect(client.history.get).toHaveLength(1);
 97 |       expect(client.history.get[0].url).toStrictEqual(url);
 98 |       expect(client.history.get[0].headers).toMatchObject({
 99 |         [API_KEY_HEADER]: expect.any(String),
100 |       });
101 |     });
102 | 
103 |     test('should list permissions w/ options', async () => {
104 |       const type = chance.string();
105 |       const description = chance.string();
106 |       const applicationTypes = [chance.string() as ApplicationType];
107 |       const _apiKey = chance.string();
108 |       const correlationId = chance.string();
109 |       const idempotencyKey = chance.string();
110 | 
111 |       client.onGet().reply(
112 |         200,
113 |         JSON.stringify([
114 |           {
115 |             type,
116 |             description,
117 |             application_types: applicationTypes,
118 |           },
119 |         ])
120 |       );
121 | 
122 |       expect(
123 |         await bt.permissions.list(undefined, {
124 |           apiKey: _apiKey,
125 |           correlationId,
126 |           idempotencyKey,
127 |         })
128 |       ).toStrictEqual([
129 |         {
130 |           type,
131 |           description,
132 |           applicationTypes,
133 |         },
134 |       ]);
135 | 
136 |       expect(client.history.get).toHaveLength(1);
137 |       expect(client.history.get[0].headers).toMatchObject({
138 |         [API_KEY_HEADER]: _apiKey,
139 |         [BT_TRACE_ID_HEADER]: correlationId,
140 |         [BT_IDEMPOTENCY_KEY_HEADER]: idempotencyKey,
141 |       });
142 |     });
143 | 
144 |     test('should reject with status >= 400 <= 599', async () => {
145 |       const status = errorStatus();
146 | 
147 |       client.onGet().reply(status);
148 | 
149 |       const promise = bt.permissions.list();
150 | 
151 |       await expectBasisTheoryApiError(promise, status);
152 |     });
153 |   });
154 | });
155 | 


--------------------------------------------------------------------------------
/test/proxies.test.ts:
--------------------------------------------------------------------------------
  1 | import type MockAdapter from 'axios-mock-adapter';
  2 | import { Chance } from 'chance';
  3 | import { BasisTheory } from '@/BasisTheory';
  4 | import { API_KEY_HEADER } from '@/common';
  5 | import { transformProxyRequestSnakeCase } from '@/common/utils';
  6 | import type { BasisTheory as IBasisTheory } from '@/types/sdk';
  7 | import { mockServiceClient, testCRUD, testPatch } from './setup/utils';
  8 | 
  9 | describe('Proxies', () => {
 10 |   let bt: IBasisTheory,
 11 |     chance: Chance.Chance,
 12 |     apiKey: string,
 13 |     client: MockAdapter;
 14 | 
 15 |   beforeAll(async () => {
 16 |     chance = new Chance();
 17 |     apiKey = chance.string();
 18 |     bt = await new BasisTheory().init(apiKey);
 19 |     client = mockServiceClient(bt.proxies);
 20 |   });
 21 | 
 22 |   beforeEach(() => {
 23 |     client.resetHandlers();
 24 |     client.resetHistory();
 25 |   });
 26 | 
 27 |   describe('CRUD', () => {
 28 |     const _chance = new Chance();
 29 | 
 30 |     const createPayload = {
 31 |       name: _chance.animal(),
 32 |       destinationUrl: _chance.url(),
 33 |       requestTransform: {
 34 |         code: _chance.string(),
 35 |       },
 36 |       responseTransform: {
 37 |         code: _chance.string(),
 38 |       },
 39 |       application: {
 40 |         id: _chance.guid(),
 41 |       },
 42 |       configuration: {
 43 |         snake_case: _chance.string(),
 44 |         camelCase: _chance.string(),
 45 |       },
 46 |       requireAuth: _chance.bool(),
 47 |     };
 48 | 
 49 |     const updatePayload = {
 50 |       name: _chance.animal(),
 51 |       destinationUrl: _chance.url(),
 52 |       requestTransform: {
 53 |         code: _chance.word(),
 54 |       },
 55 |       responseTransform: {
 56 |         code: _chance.word(),
 57 |       },
 58 |       application: {
 59 |         id: _chance.guid(),
 60 |       },
 61 |       configuration: {
 62 |         snake_case: _chance.string(),
 63 |         camelCase: _chance.string(),
 64 |       },
 65 |       requireAuth: _chance.bool(),
 66 |     };
 67 | 
 68 |     const patchPayload = {
 69 |       ...updatePayload,
 70 |     };
 71 | 
 72 |     const transformedCreatePayload = transformProxyRequestSnakeCase(
 73 |       createPayload
 74 |     );
 75 | 
 76 |     const transformedUpdatePayload = transformProxyRequestSnakeCase(
 77 |       updatePayload
 78 |     );
 79 | 
 80 |     const transformedPatchPayload = transformProxyRequestSnakeCase(
 81 |       patchPayload
 82 |     );
 83 | 
 84 |     testCRUD(() => ({
 85 |       service: bt.proxies,
 86 |       client,
 87 |       createPayload,
 88 |       transformedCreatePayload,
 89 |       updatePayload,
 90 |       transformedUpdatePayload,
 91 |     }));
 92 | 
 93 |     testPatch(() => ({
 94 |       service: bt.proxies,
 95 |       client,
 96 |       patchPayload,
 97 |       transformedPatchPayload,
 98 |     }));
 99 | 
100 |     test('should list w/o changing config casing', async () => {
101 |       const randomString = _chance.string();
102 |       const randomNumber = _chance.integer();
103 | 
104 |       client.onGet().reply(
105 |         200,
106 |         JSON.stringify({
107 |           pagination: {
108 |             total_items: randomNumber,
109 |             page_number: randomNumber,
110 |             page_size: randomNumber,
111 |             total_pages: randomNumber,
112 |           },
113 |           data: [
114 |             {
115 |               id: '1',
116 |               snake_case: randomString,
117 |               configuration: {
118 |                 snake_case: randomString,
119 |                 camelCase: randomString,
120 |               },
121 |             },
122 |             {
123 |               id: '2',
124 |               snake_case: randomString,
125 |               configuration: {
126 |                 snake_case: randomString,
127 |                 camelCase: randomString,
128 |               },
129 |             },
130 |           ],
131 |         })
132 |       );
133 | 
134 |       expect(await bt.proxies.list()).toStrictEqual({
135 |         pagination: {
136 |           totalItems: randomNumber,
137 |           pageNumber: randomNumber,
138 |           pageSize: randomNumber,
139 |           totalPages: randomNumber,
140 |         },
141 |         data: [
142 |           {
143 |             id: '1',
144 |             snakeCase: randomString,
145 |             configuration: {
146 |               snake_case: randomString,
147 |               camelCase: randomString,
148 |             },
149 |           },
150 |           {
151 |             id: '2',
152 |             snakeCase: randomString,
153 |             configuration: {
154 |               snake_case: randomString,
155 |               camelCase: randomString,
156 |             },
157 |           },
158 |         ],
159 |       });
160 |       expect(client.history.get).toHaveLength(1);
161 |       expect(client.history.get[0].url).toStrictEqual('/');
162 |       expect(client.history.get[0].headers).toMatchObject({
163 |         [API_KEY_HEADER]: expect.any(String),
164 |       });
165 |     });
166 |   });
167 | });
168 | 


--------------------------------------------------------------------------------
/test/reactor-formulas.test.ts:
--------------------------------------------------------------------------------
 1 | import MockAdapter from 'axios-mock-adapter';
 2 | import { Chance } from 'chance';
 3 | import { BasisTheory } from '@/BasisTheory';
 4 | import type {
 5 |   ReactorFormulaConfig,
 6 |   FormulaType,
 7 |   DataType,
 8 | } from '@/types/models';
 9 | import type { BasisTheory as IBasisTheory } from '@/types/sdk';
10 | import { testCRUD, mockServiceClient } from './setup/utils';
11 | 
12 | describe('Reactor Formulas', () => {
13 |   let bt: IBasisTheory,
14 |     chance: Chance.Chance,
15 |     apiKey: string,
16 |     client: MockAdapter;
17 | 
18 |   beforeAll(async () => {
19 |     chance = new Chance();
20 |     apiKey = chance.string();
21 |     bt = await new BasisTheory().init(apiKey);
22 |     client = mockServiceClient(bt.reactorFormulas);
23 |   });
24 | 
25 |   beforeEach(() => {
26 |     client.resetHandlers();
27 |     client.resetHistory();
28 |   });
29 | 
30 |   describe('CRUD', () => {
31 |     testCRUD(() => ({
32 |       service: bt.reactorFormulas,
33 |       client,
34 |       createPayload: {
35 |         name: chance.string(),
36 |         description: chance.string(),
37 |         type: chance.string() as FormulaType,
38 |         icon: chance.string(),
39 |         code: chance.string(),
40 |         configuration: [
41 |           {
42 |             name: chance.string(),
43 |             description: chance.string(),
44 |             type: chance.string() as DataType,
45 |           } as ReactorFormulaConfig,
46 |         ],
47 |         requestParameters: [
48 |           {
49 |             name: chance.string(),
50 |             description: chance.string(),
51 |             type: chance.string() as DataType,
52 |             optional: chance.bool(),
53 |           },
54 |         ],
55 |       },
56 |       updatePayload: {
57 |         name: chance.string(),
58 |         description: chance.string(),
59 |         type: chance.string() as FormulaType,
60 |         icon: chance.string(),
61 |         code: chance.string(),
62 |         configuration: [
63 |           {
64 |             name: chance.string(),
65 |             description: chance.string(),
66 |             type: chance.string() as DataType,
67 |           } as ReactorFormulaConfig,
68 |         ],
69 |         requestParameters: [
70 |           {
71 |             name: chance.string(),
72 |             description: chance.string(),
73 |             type: chance.string() as DataType,
74 |             optional: chance.bool(),
75 |           },
76 |         ],
77 |       },
78 |     }));
79 |   });
80 | });
81 | 


--------------------------------------------------------------------------------
/test/script.test.ts:
--------------------------------------------------------------------------------
 1 | import { findScript, injectScript } from '@/elements/script';
 2 | import { describeif } from './setup/utils';
 3 | 
 4 | describe('Script', () => {
 5 |   describeif(typeof window === 'object')('scripts', () => {
 6 |     afterEach(() => {
 7 |       document.querySelectorAll('html')[0].innerHTML = '';
 8 |     });
 9 | 
10 |     test('should find existing script', () => {
11 |       const existingScript = document.createElement('script');
12 | 
13 |       existingScript.src = 'source?param=1';
14 |       document.head.append(existingScript);
15 | 
16 |       expect(findScript('source')).toBe(existingScript);
17 |     });
18 | 
19 |     test('should inject script in document.head', () => {
20 |       const script = injectScript('source');
21 | 
22 |       expect(document.head.children[0]).toBe(script);
23 |     });
24 | 
25 |     test('should inject script in document.body', () => {
26 |       document.head.remove();
27 | 
28 |       const script = injectScript('source');
29 | 
30 |       expect(document.body.children[0]).toBe(script);
31 |     });
32 | 
33 |     test("should throw error when can't inject script", () => {
34 |       document.head.remove();
35 |       document.body.remove();
36 | 
37 |       expect(() => injectScript('source')).toThrow(
38 |         'No <head> or <body> elements found in document.'
39 |       );
40 |     });
41 |   });
42 | });
43 | 


--------------------------------------------------------------------------------
/test/sessions.test.ts:
--------------------------------------------------------------------------------
 1 | import MockAdapter from 'axios-mock-adapter';
 2 | import { Chance } from 'chance';
 3 | import { BasisTheory } from '@/BasisTheory';
 4 | import { API_KEY_HEADER } from '@/common';
 5 | import type {
 6 |   AuthorizeSessionRequest,
 7 |   BasisTheory as IBasisTheory,
 8 | } from '@/types/sdk';
 9 | import { mockServiceClient } from './setup/utils';
10 | 
11 | describe('Sessions', () => {
12 |   let bt: IBasisTheory,
13 |     chance: Chance.Chance,
14 |     apiKey: string,
15 |     client: MockAdapter;
16 | 
17 |   beforeAll(async () => {
18 |     chance = new Chance();
19 |     apiKey = chance.string();
20 |     bt = await new BasisTheory().init(apiKey);
21 |     client = mockServiceClient(bt.sessions);
22 |   });
23 | 
24 |   beforeEach(() => {
25 |     client.resetHandlers();
26 |     client.resetHistory();
27 |   });
28 | 
29 |   describe('create', () => {
30 |     test('should create session', async () => {
31 |       const sessionKey = chance.string();
32 |       const nonce = chance.string();
33 |       const expiresAt = chance.string();
34 | 
35 |       client.onPost('/').reply(
36 |         201,
37 | 
38 |         JSON.stringify({
39 |           session_key: sessionKey,
40 |           nonce,
41 |           expires_at: expiresAt,
42 |         })
43 |       );
44 | 
45 |       expect(await bt.sessions.create()).toStrictEqual({
46 |         sessionKey,
47 |         nonce,
48 |         expiresAt,
49 |       });
50 |       expect(client.history.post).toHaveLength(1);
51 |       expect(client.history.post[0].headers).toMatchObject({
52 |         [API_KEY_HEADER]: expect.any(String),
53 |       });
54 |     });
55 |   });
56 | 
57 |   describe('authorize', () => {
58 |     test('should authorize session', async () => {
59 |       const authorizeSessionRequest: AuthorizeSessionRequest = {
60 |         nonce: chance.string(),
61 |       };
62 | 
63 |       client.onPost('/authorize').reply(200, JSON.stringify({}));
64 | 
65 |       expect(
66 |         await bt.sessions.authorize(authorizeSessionRequest)
67 |       ).toStrictEqual({});
68 |       expect(client.history.post).toHaveLength(1);
69 |       expect(client.history.post[0].headers).toMatchObject({
70 |         [API_KEY_HEADER]: expect.any(String),
71 |       });
72 |     });
73 |   });
74 | });
75 | 


--------------------------------------------------------------------------------
/test/token-intents.test.ts:
--------------------------------------------------------------------------------
 1 | import MockAdapter from 'axios-mock-adapter';
 2 | import { Chance } from 'chance';
 3 | import { BasisTheory } from '@/BasisTheory';
 4 | import { transformTokenRequestSnakeCase } from '@/common';
 5 | import type { CreateTokenIntent, DataObject } from '@/types/models';
 6 | import type { BasisTheory as IBasisTheory } from '@/types/sdk';
 7 | import { mockServiceClient, testCreate, testDelete } from './setup/utils';
 8 | 
 9 | describe('Token Intents', () => {
10 |   const chance = new Chance();
11 |   let bt: IBasisTheory, apiKey: string, client: MockAdapter;
12 | 
13 |   beforeAll(async () => {
14 |     apiKey = chance.string();
15 |     bt = await new BasisTheory().init(apiKey);
16 |     client = mockServiceClient(bt.tokenIntents);
17 |   });
18 | 
19 |   beforeEach(() => {
20 |     client.resetHandlers();
21 |     client.resetHistory();
22 |   });
23 | 
24 |   describe('create', () => {
25 |     const createPayload: CreateTokenIntent = {
26 |       type: 'card',
27 |       data: {
28 |         number: chance.integer(),
29 |         expirationMonth: chance.date().getMonth(),
30 |         expirationYear: chance.date().getFullYear(),
31 |         cvc: chance.integer().toString(),
32 |       },
33 |     };
34 | 
35 |     testCreate(() => ({
36 |       service: bt.tokenIntents,
37 |       client,
38 |       createPayload,
39 |       transformedCreatePayload: transformTokenRequestSnakeCase<DataObject>(
40 |         createPayload
41 |       ),
42 |     }));
43 |   });
44 | 
45 |   describe('delete', () => {
46 |     testDelete(() => ({
47 |       service: bt.tokenIntents,
48 |       client,
49 |     }));
50 |   });
51 | });
52 | 


--------------------------------------------------------------------------------
/test/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "include": ["../src/**/*", "./**/*"],
 3 |   "compilerOptions": {
 4 |     "baseUrl": "..",
 5 |     "paths": {
 6 |       "@/*": ["src/*"]
 7 |     }
 8 |   }
 9 | }
10 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "include": ["src/**/*"],
 3 |   "compilerOptions": {
 4 |     "target": "es6",
 5 |     "module": "esnext",
 6 |     "lib": ["dom", "esnext"],
 7 |     "importHelpers": true,
 8 |     "declaration": true,
 9 |     "emitDeclarationOnly": true,
10 |     "outDir": "dist",
11 |     "strict": true,
12 |     "noFallthroughCasesInSwitch": true,
13 |     "moduleResolution": "node",
14 |     "esModuleInterop": true,
15 |     "skipLibCheck": true,
16 |     "forceConsistentCasingInFileNames": true,
17 |     "downlevelIteration": true,
18 |     "baseUrl": ".",
19 |     "paths": {
20 |       "@/*": ["src/*"]
21 |     }
22 |   }
23 | }
24 | 


--------------------------------------------------------------------------------
/webpack.common.js:
--------------------------------------------------------------------------------
 1 | const path = require('path');
 2 | const Dotenv = require('dotenv-webpack');
 3 | const { merge } = require('webpack-merge');
 4 | const babelConfig = require('./babel.bundle.config');
 5 | const TsconfigPathsPlugin = require('tsconfig-paths-webpack-plugin');
 6 | 
 7 | const base = {
 8 |   target: ['web', 'es6'],
 9 |   entry: path.resolve(__dirname, 'src'),
10 | 
11 |   output: {
12 |     path: path.resolve(__dirname, 'dist'),
13 |     globalObject: "typeof self !== 'undefined' ? self : this",
14 |   },
15 | 
16 |   resolve: {
17 |     plugins: [new TsconfigPathsPlugin({})],
18 |     extensions: ['.ts', '.tsx', '.js', '.json'],
19 |     fallback: {
20 |       crypto: false,
21 |       stream: false,
22 |       os: require.resolve('os-browserify/browser'),
23 |       process: false,
24 |     },
25 |   },
26 | 
27 |   module: {
28 |     rules: [
29 |       {
30 |         include: [path.resolve(__dirname, 'src')],
31 |         test: /\.(ts|js)x?$/u,
32 |         loader: 'babel-loader',
33 |         options: babelConfig,
34 |       },
35 |     ],
36 |   },
37 | 
38 |   plugins: [new Dotenv()],
39 | };
40 | 
41 | const umd = merge(base, {
42 |   output: {
43 |     filename: 'basis-theory-js.bundle.js',
44 |     library: 'BasisTheory',
45 |     libraryTarget: 'umd',
46 |     libraryExport: '_instance',
47 |   },
48 | });
49 | 
50 | module.exports = [
51 |   umd,
52 |   // other configs like `cjs` or `esm` could go here
53 | ];
54 | 


--------------------------------------------------------------------------------
/webpack.dev.js:
--------------------------------------------------------------------------------
 1 | const BundleAnalyzerPlugin = require('webpack-bundle-analyzer')
 2 |   .BundleAnalyzerPlugin;
 3 | const { merge } = require('webpack-merge');
 4 | const configs = require('./webpack.common');
 5 | 
 6 | const dev = {
 7 |   mode: 'development',
 8 |   devtool: 'source-map',
 9 |   plugins: [new BundleAnalyzerPlugin()],
10 | };
11 | 
12 | module.exports = configs.map((config) => merge(config, dev));
13 | 


--------------------------------------------------------------------------------
/webpack.prod.js:
--------------------------------------------------------------------------------
1 | const { merge } = require('webpack-merge');
2 | const configs = require('./webpack.common');
3 | 
4 | const prod = {
5 |   mode: 'production',
6 | };
7 | 
8 | module.exports = configs.map((config) => merge(config, prod));
9 | 


--------------------------------------------------------------------------------