@dfns/sdk 0.2.2 → 0.2.3-rc.1

package/codegen/Auth/index.ts

@@ -0,0 +1,3 @@
+export * from './AuthClient'
+export * from './DelegatedAuthClient'
+export * from './types'

package/codegen/Auth/types.ts

@@ -0,0 +1,262 @@
+import * as Auth from '../datamodel/Auth'
+import * as Foundations from '../datamodel/Foundations'
+
+export type CreateDelegatedUserRegistrationRequest = {
+  body: Auth.CreateUserInput
+}
+
+export type CreateDelegatedUserRegistrationResponse =
+  Auth.UserRegistrationChallenge
+
+export type CreateUserRegistrationRequest = {
+  body: Auth.CreateUserRegistrationInput
+}
+
+export type CreateUserRegistrationResponse = Auth.UserRegistration
+
+export type CreateDelegatedUserLoginRequest = {
+  body: Auth.CreateDelegatedUserLoginInput
+}
+
+export type CreateDelegatedUserLoginResponse = Auth.UserLogin
+
+export type CreateUserActionSignatureChallengeRequest = {
+  body: Auth.CreateUserActionSignatureChallengeInput
+}
+
+export type CreateUserActionSignatureChallengeResponse = Auth.UserLoginChallenge
+
+export type CreateUserActionSignatureRequest = {
+  body: Auth.CreateUserLoginInput
+}
+
+export type CreateUserActionSignatureResponse = Auth.UserActionSignature
+
+export type CreateUserCredentialChallengeRequest = {
+  body: Auth.CreateUserCredentialChallengeInput
+}
+
+export type CreateUserCredentialChallengeResponse = Auth.UserCredentialChallenge
+
+export type CreateUserCredentialRequest = {
+  body: Auth.CreateUserCredentialInput
+}
+
+export type CreateUserCredentialResponse = Auth.CredentialInfo
+
+export type ActivateCredentialRequest = {
+  body: Auth.ActivateCredentialInput
+}
+
+export type ActivateCredentialResponse = Auth.GenericSuccessMessage
+
+export type DeactivateCredentialRequest = {
+  body: Auth.ActivateCredentialInput
+}
+
+export type DeactivateCredentialResponse = Auth.GenericSuccessMessage
+
+export type ListUserCredentialsResponse = { items: Auth.CredentialInfo[] }
+
+export type CreateUserActionSignatureFromCodeRequest = {
+  body: Auth.CreateUserLoginFromCodeInput
+}
+
+export type CreateUserActionSignatureFromCodeResponse = Auth.UserActionSignature
+
+export type CreateCodeUserActionSignatureChallengeRequest = {
+  body: Auth.CreateCodeLoginChallengeInput
+}
+
+export type CreateCodeUserActionSignatureChallengeResponse =
+  Auth.UserLoginChallenge
+
+export type CreateCodeUserActionSignatureRequest = {
+  body: Auth.CreateUserLoginInput
+}
+
+export type CreateCodeUserActionSignatureResponse = Auth.GenericSuccessMessage
+
+export type ListPersonalAccessTokensResponse = {
+  items: Auth.AccessTokenInfoWithPublicKey[]
+}
+
+export type CreatePersonalAccessTokenRequest = {
+  body: Auth.CreateAccessTokenInput
+}
+
+export type CreatePersonalAccessTokenResponse =
+  Auth.AccessTokenInfoWithPublicKey
+
+export type GetPersonalAccessTokensRequest = {
+  tokenId: Foundations.EntityId
+}
+
+export type GetPersonalAccessTokensResponse = Auth.AccessTokenInfoWithPublicKey
+
+export type UpdatePersonalAccessTokenRequest = {
+  tokenId: Foundations.EntityId
+  body: Auth.UpdateAccessTokenInput
+}
+
+export type UpdatePersonalAccessTokenResponse =
+  Auth.AccessTokenInfoWithPublicKey
+
+export type ArchivePersonalAccessTokenRequest = {
+  tokenId: Foundations.EntityId
+}
+
+export type ArchivePersonalAccessTokenResponse =
+  Auth.AccessTokenInfoWithPublicKey
+
+export type ActivatePersonalAccessTokenRequest = {
+  tokenId: Foundations.EntityId
+}
+
+export type ActivatePersonalAccessTokenResponse =
+  Auth.AccessTokenInfoWithPublicKey
+
+export type DeactivatePersonalAccessTokenRequest = {
+  tokenId: Foundations.EntityId
+}
+
+export type DeactivatePersonalAccessTokenResponse =
+  Auth.AccessTokenInfoWithPublicKey
+
+export type ListServiceAccountsResponse = {
+  items: Auth.UserAccessTokenInformation[]
+}
+
+export type CreateServiceAccountRequest = {
+  body: Auth.CreateAccessTokenInput
+}
+
+export type CreateServiceAccountResponse = Auth.UserAccessTokenInformation
+
+export type GetServiceAccountRequest = {
+  serviceAccountId: Foundations.EntityId
+}
+
+export type GetServiceAccountResponse = Auth.UserAccessTokenInformation
+
+export type UpdateServiceAccountRequest = {
+  serviceAccountId: Foundations.EntityId
+  body: Auth.UpdateAccessTokenInput
+}
+
+export type UpdateServiceAccountResponse = Auth.UserAccessTokenInformation
+
+export type ArchiveServiceAccountRequest = {
+  serviceAccountId: Foundations.EntityId
+}
+
+export type ArchiveServiceAccountResponse = Auth.UserAccessTokenInformation
+
+export type ActivateServiceAccountRequest = {
+  serviceAccountId: Foundations.EntityId
+}
+
+export type ActivateServiceAccountResponse = Auth.UserAccessTokenInformation
+
+export type DeactivateServiceAccountRequest = {
+  serviceAccountId: Foundations.EntityId
+}
+
+export type DeactivateServiceAccountResponse = Auth.UserAccessTokenInformation
+
+export type ListUsersResponse = { items: Auth.UserInfo[] }
+
+export type CreateUserRequest = {
+  body: Auth.CreateUserInput
+}
+
+export type CreateUserResponse = Auth.UserInfo
+
+export type GetUserRequest = {
+  userId: Foundations.EntityId
+}
+
+export type GetUserResponse = Auth.UserInfo
+
+export type UpdateUserRequest = {
+  userId: Foundations.EntityId
+  body: Auth.UpdateUserInput
+}
+
+export type UpdateUserResponse = Auth.UserInfo
+
+export type ArchiveUserRequest = {
+  userId: Foundations.EntityId
+}
+
+export type ArchiveUserResponse = Auth.UserInfo
+
+export type ActivateUserRequest = {
+  userId: Foundations.EntityId
+}
+
+export type ActivateUserResponse = Auth.UserInfo
+
+export type DeactivateUserRequest = {
+  userId: Foundations.EntityId
+}
+
+export type DeactivateUserResponse = Auth.UserInfo
+
+export type ListApplicationsResponse = { items: Auth.AppInfoWithPublicKey[] }
+
+export type CreateApplicationRequest = {
+  body: Auth.CreateApplicationInput
+}
+
+export type CreateApplicationResponse = Auth.AppInfoWithPublicKey
+
+export type GetApplicationRequest = {
+  appId: Foundations.EntityId
+}
+
+export type GetApplicationResponse = Auth.AppInfoWithPublicKey
+
+export type UpdateApplicationRequest = {
+  appId: Foundations.EntityId
+  body: Auth.UpdateApplicationInput
+}
+
+export type UpdateApplicationResponse = Auth.AppInfoWithPublicKey
+
+export type ArchiveApplicationRequest = {
+  appId: Foundations.EntityId
+}
+
+export type ArchiveApplicationResponse = Auth.AppInfoWithPublicKey
+
+export type ActivateApplicationRequest = {
+  appId: Foundations.EntityId
+}
+
+export type ActivateApplicationResponse = Auth.AppInfoWithPublicKey
+
+export type DeactivateApplicationRequest = {
+  appId: Foundations.EntityId
+}
+
+export type DeactivateApplicationResponse = Auth.AppInfoWithPublicKey
+
+export type CreateUserRecoveryRequest = {
+  body: Auth.CreateUserRecoveryInput
+}
+
+export type CreateUserRecoveryResponse = Auth.UserRegistration
+
+export type RestartDelegatedUserRegistrationRequest = {
+  body: Auth.CreateUserInput
+}
+
+export type RestartDelegatedUserRegistrationResponse =
+  Auth.UserRegistrationChallenge
+
+export type CreateDelegatedUserRecoveryRequest = {
+  body: Auth.CreateDelegatedUserRecoveryInput
+}
+
+export type CreateDelegatedUserRecoveryResponse = Auth.UserRecoveryChallenge

package/codegen/Blockchains/BlockchainsClient.ts

@@ -0,0 +1,25 @@
+import { DfnsApiClientOptions } from '../../dfnsApiClient'
+import { simpleFetch } from '../../utils/fetch'
+import { buildPathAndQuery } from '../../utils/url'
+import * as T from './types'
+
+export class BlockchainsClient {
+  constructor(private apiOptions: DfnsApiClientOptions) {}
+
+  async callViewFunction(
+    request: T.CallViewFunctionRequest
+  ): Promise<T.CallViewFunctionResponse> {
+    const path = buildPathAndQuery('/blockchains/:network/call-read-function', {
+      path: { network: request.network },
+      query: {},
+    })
+
+    const response = await simpleFetch(path, {
+      method: 'POST',
+      body: request.body,
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+}

package/codegen/Blockchains/DelegatedBlockchainsClient.ts

@@ -0,0 +1,25 @@
+import { DfnsDelegatedApiClientOptions } from '../../dfnsDelegatedApiClient'
+import { simpleFetch } from '../../utils/fetch'
+import { buildPathAndQuery } from '../../utils/url'
+import * as T from './types'
+
+export class DelegatedBlockchainsClient {
+  constructor(private apiOptions: DfnsDelegatedApiClientOptions) {}
+
+  async callViewFunction(
+    request: T.CallViewFunctionRequest
+  ): Promise<T.CallViewFunctionResponse> {
+    const path = buildPathAndQuery('/blockchains/:network/call-read-function', {
+      path: { network: request.network },
+      query: {},
+    })
+
+    const response = await simpleFetch(path, {
+      method: 'POST',
+      body: request.body,
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+}

package/codegen/Blockchains/index.ts

@@ -0,0 +1,3 @@
+export * from './BlockchainsClient'
+export * from './DelegatedBlockchainsClient'
+export * from './types'

package/codegen/Blockchains/types.ts

@@ -0,0 +1,8 @@
+import * as Blockchains from '../datamodel/Blockchains'
+
+export type CallViewFunctionRequest = {
+  network: string
+  body: Blockchains.CallViewFunctionInput
+}
+
+export type CallViewFunctionResponse = Blockchains.CallViewFunctionResult

package/codegen/Callbacks/CallbacksClient.ts

@@ -0,0 +1,107 @@
+import { DfnsApiClientOptions } from '../../dfnsApiClient'
+import { simpleFetch, userActionFetch } from '../../utils/fetch'
+import { buildPathAndQuery } from '../../utils/url'
+import * as T from './types'
+
+export class CallbacksClient {
+  constructor(private apiOptions: DfnsApiClientOptions) {}
+
+  async createCallbackSubscription(
+    request: T.CreateCallbackSubscriptionRequest
+  ): Promise<T.CreateCallbackSubscriptionResponse> {
+    const path = buildPathAndQuery('/callback-subscriptions', {
+      path: {},
+      query: {},
+    })
+
+    const response = await userActionFetch(path, {
+      method: 'POST',
+      body: request.body,
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async getCallbackSubscriptionById(
+    request: T.GetCallbackSubscriptionByIdRequest
+  ): Promise<T.GetCallbackSubscriptionByIdResponse> {
+    const path = buildPathAndQuery(
+      '/callback-subscriptions/:callbackSubscriptionId',
+      {
+        path: { callbackSubscriptionId: request.callbackSubscriptionId },
+        query: {},
+      }
+    )
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async listCallbackSubscriptions(): Promise<T.ListCallbackSubscriptionsResponse> {
+    const path = buildPathAndQuery('/callback-subscriptions', {
+      path: {},
+      query: {},
+    })
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async archiveCallbackSubscription(
+    request: T.ArchiveCallbackSubscriptionRequest
+  ): Promise<T.ArchiveCallbackSubscriptionResponse> {
+    const path = buildPathAndQuery(
+      '/callback-subscriptions/:callbackSubscriptionId',
+      {
+        path: { callbackSubscriptionId: request.callbackSubscriptionId },
+        query: {},
+      }
+    )
+
+    const response = await userActionFetch(path, {
+      method: 'DELETE',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async getCallbackEventById(
+    request: T.GetCallbackEventByIdRequest
+  ): Promise<T.GetCallbackEventByIdResponse> {
+    const path = buildPathAndQuery('/callback-events/:callbackEventId', {
+      path: { callbackEventId: request.callbackEventId },
+      query: {},
+    })
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async listCallbackEvents(): Promise<T.ListCallbackEventsResponse> {
+    const path = buildPathAndQuery('/callback-events', {
+      path: {},
+      query: {},
+    })
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+}

package/codegen/Callbacks/DelegatedCallbacksClient.ts

@@ -0,0 +1,172 @@
+import {
+  BaseAuthApi,
+  SignUserActionChallengeRequest,
+  UserActionChallengeResponse,
+} from '../../baseAuthApi'
+import { DfnsDelegatedApiClientOptions } from '../../dfnsDelegatedApiClient'
+import { simpleFetch } from '../../utils/fetch'
+import { buildPathAndQuery } from '../../utils/url'
+import * as T from './types'
+
+export class DelegatedCallbacksClient {
+  constructor(private apiOptions: DfnsDelegatedApiClientOptions) {}
+
+  async createCallbackSubscriptionInit(
+    request: T.CreateCallbackSubscriptionRequest
+  ): Promise<UserActionChallengeResponse> {
+    const path = buildPathAndQuery('/callback-subscriptions', {
+      path: {},
+      query: {},
+    })
+
+    const challenge = await BaseAuthApi.createUserActionChallenge(
+      {
+        userActionHttpMethod: 'POST',
+        userActionHttpPath: path,
+        userActionPayload: JSON.stringify(request.body),
+        userActionServerKind: 'Api',
+      },
+      this.apiOptions
+    )
+
+    return challenge
+  }
+
+  async createCallbackSubscriptionComplete(
+    request: T.CreateCallbackSubscriptionRequest,
+    signedChallenge: SignUserActionChallengeRequest
+  ): Promise<T.CreateCallbackSubscriptionResponse> {
+    const path = buildPathAndQuery('/callback-subscriptions', {
+      path: {},
+      query: {},
+    })
+
+    const { userAction } = await BaseAuthApi.signUserActionChallenge(
+      signedChallenge,
+      this.apiOptions
+    )
+
+    const response = await simpleFetch(path, {
+      method: 'POST',
+      body: request.body,
+      headers: { 'x-dfns-useraction': userAction },
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async getCallbackSubscriptionById(
+    request: T.GetCallbackSubscriptionByIdRequest
+  ): Promise<T.GetCallbackSubscriptionByIdResponse> {
+    const path = buildPathAndQuery(
+      '/callback-subscriptions/:callbackSubscriptionId',
+      {
+        path: { callbackSubscriptionId: request.callbackSubscriptionId },
+        query: {},
+      }
+    )
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async listCallbackSubscriptions(): Promise<T.ListCallbackSubscriptionsResponse> {
+    const path = buildPathAndQuery('/callback-subscriptions', {
+      path: {},
+      query: {},
+    })
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async archiveCallbackSubscriptionInit(
+    request: T.ArchiveCallbackSubscriptionRequest
+  ): Promise<UserActionChallengeResponse> {
+    const path = buildPathAndQuery(
+      '/callback-subscriptions/:callbackSubscriptionId',
+      {
+        path: { callbackSubscriptionId: request.callbackSubscriptionId },
+        query: {},
+      }
+    )
+
+    const challenge = await BaseAuthApi.createUserActionChallenge(
+      {
+        userActionHttpMethod: 'DELETE',
+        userActionHttpPath: path,
+        userActionPayload: JSON.stringify({}),
+        userActionServerKind: 'Api',
+      },
+      this.apiOptions
+    )
+
+    return challenge
+  }
+
+  async archiveCallbackSubscriptionComplete(
+    request: T.ArchiveCallbackSubscriptionRequest,
+    signedChallenge: SignUserActionChallengeRequest
+  ): Promise<T.ArchiveCallbackSubscriptionResponse> {
+    const path = buildPathAndQuery(
+      '/callback-subscriptions/:callbackSubscriptionId',
+      {
+        path: { callbackSubscriptionId: request.callbackSubscriptionId },
+        query: {},
+      }
+    )
+
+    const { userAction } = await BaseAuthApi.signUserActionChallenge(
+      signedChallenge,
+      this.apiOptions
+    )
+
+    const response = await simpleFetch(path, {
+      method: 'DELETE',
+      body: {},
+      headers: { 'x-dfns-useraction': userAction },
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async getCallbackEventById(
+    request: T.GetCallbackEventByIdRequest
+  ): Promise<T.GetCallbackEventByIdResponse> {
+    const path = buildPathAndQuery('/callback-events/:callbackEventId', {
+      path: { callbackEventId: request.callbackEventId },
+      query: {},
+    })
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async listCallbackEvents(): Promise<T.ListCallbackEventsResponse> {
+    const path = buildPathAndQuery('/callback-events', {
+      path: {},
+      query: {},
+    })
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+}

package/codegen/Callbacks/index.ts

@@ -0,0 +1,3 @@
+export * from './CallbacksClient'
+export * from './DelegatedCallbacksClient'
+export * from './types'

package/codegen/Callbacks/{types.d.ts → types.ts}

@@ -1,23 +1,31 @@
-import * as Callbacks from '../datamodel/Callbacks';
+import * as Callbacks from '../datamodel/Callbacks'
+
 export type CreateCallbackSubscriptionRequest = {
-    body: Callbacks.CreateCallbackSubscriptionInput;
-};
-export type CreateCallbackSubscriptionResponse = Callbacks.CallbackSubscription;
+  body: Callbacks.CreateCallbackSubscriptionInput
+}
+
+export type CreateCallbackSubscriptionResponse = Callbacks.CallbackSubscription
+
 export type GetCallbackSubscriptionByIdRequest = {
-    callbackSubscriptionId: string;
-};
-export type GetCallbackSubscriptionByIdResponse = Callbacks.CallbackSubscription;
+  callbackSubscriptionId: string
+}
+
+export type GetCallbackSubscriptionByIdResponse = Callbacks.CallbackSubscription
+
 export type ListCallbackSubscriptionsResponse = {
-    items: Callbacks.CallbackSubscription[];
-};
+  items: Callbacks.CallbackSubscription[]
+}
+
 export type ArchiveCallbackSubscriptionRequest = {
-    callbackSubscriptionId: string;
-};
-export type ArchiveCallbackSubscriptionResponse = Callbacks.CallbackSubscription;
+  callbackSubscriptionId: string
+}
+
+export type ArchiveCallbackSubscriptionResponse = Callbacks.CallbackSubscription
+
 export type GetCallbackEventByIdRequest = {
-    callbackEventId: string;
-};
-export type GetCallbackEventByIdResponse = Callbacks.CallbackEvent;
-export type ListCallbackEventsResponse = {
-    items: Callbacks.CallbackEvent[];
-};
+  callbackEventId: string
+}
+
+export type GetCallbackEventByIdResponse = Callbacks.CallbackEvent
+
+export type ListCallbackEventsResponse = { items: Callbacks.CallbackEvent[] }