feat: add application keys endpoints (#412)

* feat: adds application keys endpoints

* test: add `createKey` to application create

* fix: typo

src/BasisTheory.ts

@@ -20,6 +20,7 @@ import type {
 } from '@/types/elements';
 import type { TokenizeData } from '@/types/models';
 import type {
+  ApplicationKeys,
   Applications,
   ApplicationTemplates,
   BasisTheory as IBasisTheory,
@@ -38,11 +39,12 @@ import type {
   RequestOptions,
   Sessions,
   Tenants,
+  ThreeDS,
   Tokenize,
   Tokens,
-  ThreeDS,
 } from '@/types/sdk';
 import { BasisTheoryApplicationTemplates } from './application-templates';
+import { BasisTheoryApplicationKeys } from './applicationKeys';
 import { BasisTheoryApplications } from './applications';
 import {
   assertInit,
@@ -76,36 +78,38 @@ export class BasisTheory
   implements BasisTheoryInit, IBasisTheory, BasisTheoryElements {
   private _initStatus: BasisTheoryInitStatus = 'not-started';
 
-  private _initOptions?: Required<BasisTheoryInitOptions>;
-
-  private _tokens?: Tokens & ElementsTokens;
-
-  private _tokenize?: Tokenize & ElementsTokenize;
-
-  private _elements?: BasisTheoryElementsInternal;
+  private _applicationKeys?: BasisTheoryApplicationKeys;
 
   private _applications?: BasisTheoryApplications;
 
   private _applicationTemplates?: BasisTheoryApplicationTemplates;
 
-  private _tenants?: BasisTheoryTenants;
-
-  private _logs?: BasisTheoryLogs;
+  private _elements?: BasisTheoryElementsInternal;
 
-  private _reactorFormulas?: BasisTheoryReactorFormulas;
+  private _initOptions?: Required<BasisTheoryInitOptions>;
 
-  private _reactors?: BasisTheoryReactors;
+  private _logs?: BasisTheoryLogs;
 
   private _permissions?: BasisTheoryPermissions;
 
   private _proxies?: Proxies;
 
   private _proxy?: Proxy & ElementsProxy;
 
+  private _reactorFormulas?: BasisTheoryReactorFormulas;
+
+  private _reactors?: BasisTheoryReactors;
+
   private _sessions?: Sessions;
 
+  private _tenants?: BasisTheoryTenants;
+
   private _threeds?: ThreeDS;
 
+  private _tokenize?: Tokenize & ElementsTokenize;
+
+  private _tokens?: Tokens & ElementsTokens;
+
   public init(
     apiKey: string | undefined,
     options?: BasisTheoryInitOptionsWithoutElements
@@ -171,6 +175,11 @@ export class BasisTheory
         baseURL: new URL(CLIENT_BASE_PATHS.applications, baseUrl).toString(),
         appInfo,
       });
+      this._applicationKeys = new BasisTheoryApplicationKeys({
+        apiKey,
+        baseURL: new URL(CLIENT_BASE_PATHS.applicationKeys, baseUrl).toString(),
+        appInfo,
+      });
       this._applicationTemplates = new BasisTheoryApplicationTemplates({
         apiKey,
         baseURL: new URL(
@@ -324,6 +333,10 @@ export class BasisTheory
     return assertInit(this._applications);
   }
 
+  public get applicationKeys(): ApplicationKeys {
+    return assertInit(this._applicationKeys);
+  }
+
   public get applicationTemplates(): ApplicationTemplates {
     return assertInit(this._applicationTemplates);
   }

src/applicationKeys/BasisTheoryApplicationKeys.ts

@@ -0,0 +1,35 @@
+import { dataExtractor } from '@/common';
+import { BasisTheoryService } from '@/service';
+import { CrudBuilder } from '@/service/CrudBuilder';
+import type { ApplicationKey } from '@/types/models';
+
+export const BasisTheoryApplicationKeys = new CrudBuilder(
+  class BasisTheoryApplicationKeys extends BasisTheoryService {
+    public create(applicationId: string): Promise<ApplicationKey> {
+      return this.client.post(`${applicationId}/keys`).then(dataExtractor);
+    }
+
+    public get(applicationId: string): Promise<ApplicationKey[]> {
+      return this.client.get(`${applicationId}/keys`).then(dataExtractor);
+    }
+
+    public getById(
+      applicationId: string,
+      keyId: string
+    ): Promise<ApplicationKey> {
+      return this.client
+        .get(`${applicationId}/keys/${keyId}`)
+        .then(dataExtractor);
+    }
+
+    public delete(applicationId: string, keyId: string): Promise<void> {
+      return this.client
+        .delete(`${applicationId}/keys/${keyId}`)
+        .then(dataExtractor);
+    }
+  }
+).build();
+
+export type BasisTheoryApplicationKeys = InstanceType<
+  typeof BasisTheoryApplicationKeys
+>;

src/applicationKeys/index.ts

@@ -0,0 +1 @@
+export { BasisTheoryApplicationKeys } from './BasisTheoryApplicationKeys';

src/applications/BasisTheoryApplications.ts

@@ -23,6 +23,9 @@ export const BasisTheoryApplications = new CrudBuilder(
         .then(dataExtractor);
     }
 
+    /**
+     * @deprecated This method is deprecated. Use Terraform or https://portal.basistheory.com to manage keys instead.
+     */
     public regenerateKey(
       id: string,
       options?: RequestOptions

src/common/constants.ts

@@ -26,6 +26,7 @@ const CLIENT_BASE_PATHS: BasisTheoryServicesBasePathMap = {
   tokens: 'tokens',
   tokenize: 'tokenize',
   applications: 'applications',
+  applicationKeys: 'applications',
   applicationTemplates: 'application-templates',
   tenants: 'tenants/self',
   logs: 'logs',

src/types/models/applications.ts

@@ -10,7 +10,11 @@ interface Application extends Auditable {
   id: string;
   tenantId: string;
   name?: string;
+  /**
+   * @deprecated use `keys` instead.
+   */
   key?: string;
+  keys?: ApplicationKey[];
   type: ApplicationType;
   permissions?: string[];
   rules?: AccessRule[];
@@ -32,16 +36,24 @@ type Condition = {
   value: string;
 };
 
+type ApplicationKey = {
+  id?: string;
+  key?: string;
+  createdAt?: string;
+  createdBy?: string;
+};
+
 type CreateApplication = Pick<
   Application,
   'name' | 'type' | 'permissions' | 'rules' | 'expiresAt'
->;
+> & { createKey?: boolean };
 
 type UpdateApplication = Pick<Application, 'name' | 'permissions' | 'rules'>;
 
 export type {
-  ApplicationType,
   Application,
+  ApplicationKey,
+  ApplicationType,
   CreateApplication,
   TransformType,
   UpdateApplication,

src/types/sdk/sdk.ts

@@ -15,6 +15,7 @@ import type {
   Tokens,
   ThreeDS,
 } from './services';
+import { ApplicationKeys } from './services/applicationKeys';
 
 interface ApplicationInfo {
   name?: string;
@@ -51,6 +52,7 @@ interface BasisTheoryInit {
 }
 interface BasisTheory extends Tokenize {
   applications: Applications;
+  applicationKeys: ApplicationKeys;
   applicationTemplates: ApplicationTemplates;
   /**
    * @description Allows you to utilize element values in requests to a third-party API using our HTTP client service.

src/types/sdk/services/applicationKeys.ts

@@ -0,0 +1,10 @@
+import type { ApplicationKey } from '@/types/models';
+
+interface ApplicationKeys {
+  create(id: string): Promise<ApplicationKey>;
+  delete(applicationId: string, keyId: string): Promise<void>;
+  get(applicationId: string): Promise<ApplicationKey[]>;
+  getById(applicationId: string, keyId: string): Promise<ApplicationKey>;
+}
+
+export type { ApplicationKeys };

src/types/sdk/services/index.ts

@@ -2,6 +2,7 @@ export * from './shared';
 export * from './tokens';
 export * from './tokenize';
 export * from './applications';
+export * from './applicationKeys';
 export * from './tenants';
 export * from './logs';
 export * from './reactor-formulas';