@dfns/sdk 0.2.2 → 0.2.3-rc.1

package/baseAuthApi.ts

@@ -0,0 +1,236 @@
+import {
+  FirstFactorAttestation,
+  RecoveryFactorAttestation,
+  SecondFactorAttestation,
+  UserRegistrationChallenge,
+} from './store'
+import {
+  AllowCredential,
+  CredentialKind,
+  FirstFactorAssertion,
+  RecoveryKeyAssertion,
+  SecondFactorAssertion,
+} from './signer'
+import { HttpMethod, simpleFetch } from './utils/fetch'
+
+export type DfnsBaseApiOptions = {
+  appId: string
+  appSecret?: string
+  authToken?: string
+  baseUrl: string
+}
+
+export type CreateUserActionChallengeRequest = {
+  userActionPayload: string
+  userActionHttpMethod: HttpMethod
+  userActionHttpPath: string
+  userActionServerKind: 'Api'
+}
+
+export type CredentialFactor = 'first' | 'second' | 'either'
+
+export type UserActionChallengeResponse = {
+  supportedCredentialKinds: {
+    kind: CredentialKind
+    factor: CredentialFactor
+    requiresSecondFactor: boolean
+  }[]
+  challenge: string
+  challengeIdentifier: string
+  externalAuthenticationUrl: string
+  allowCredentials: {
+    key: AllowCredential[]
+    webauthn: AllowCredential[]
+  }
+}
+
+export type SignUserActionChallengeRequest = {
+  challengeIdentifier: string
+  firstFactor: FirstFactorAssertion
+  secondFactor?: SecondFactorAssertion
+}
+
+export type UserActionResponse = {
+  userAction: string
+}
+
+export type CreateUserLoginChallengeRequest = {
+  username: string
+  orgId: string
+}
+
+export type UserLoginChallengeResponse = UserActionChallengeResponse
+
+export type CreateUserLoginRequest = SignUserActionChallengeRequest
+
+export type UserLoginResponse = {
+  token: string
+}
+
+export type CreateUserRegistrationChallengeRequest = {
+  orgId: string
+  username: string
+  registrationCode: string
+}
+
+export type UserRegistrationChallengeResponse = UserRegistrationChallenge
+
+export type CreateUserRegistrationRequest = {
+  firstFactorCredential: FirstFactorAttestation
+  secondFactorCredential?: SecondFactorAttestation
+  recoveryCredential?: RecoveryFactorAttestation
+}
+
+export type UserRegistrationResponse = {
+  credential: {
+    uuid: string
+    kind: CredentialKind
+    name: string
+  }
+  user: {
+    id: string
+    username: string
+    orgId: string
+  }
+}
+
+export type CreateUserRecoveryRequest = {
+  recovery: RecoveryKeyAssertion
+  newCredentials: {
+    firstFactorCredential: FirstFactorAttestation
+    secondFactorCredential?: SecondFactorAttestation
+    recoveryCredential?: RecoveryFactorAttestation
+  }
+}
+
+export type UserRecoveryResponse = UserRegistrationResponse
+
+export class BaseAuthApi {
+  /**
+   * Creates a user action challenge
+   */
+  static async createUserActionChallenge(
+    request: CreateUserActionChallengeRequest,
+    options: DfnsBaseApiOptions
+  ): Promise<UserActionChallengeResponse> {
+    const response = await simpleFetch('/auth/action/init', {
+      method: 'POST',
+      body: request,
+      apiOptions: options,
+    })
+
+    return response.json()
+  }
+
+  /**
+   * Sign a user action challenge
+   */
+  static async signUserActionChallenge(
+    request: SignUserActionChallengeRequest,
+    options: DfnsBaseApiOptions
+  ): Promise<UserActionResponse> {
+    const response = await simpleFetch('/auth/action', {
+      method: 'POST',
+      body: request,
+      apiOptions: options,
+    })
+
+    return response.json()
+  }
+
+  /**
+   * Initiates user login, by creating a challenge that will need to be signed by the user Credentials.
+   */
+  static async createUserLoginChallenge(
+    request: CreateUserLoginChallengeRequest,
+    options: DfnsBaseApiOptions
+  ): Promise<UserLoginChallengeResponse> {
+    const response = await simpleFetch('/auth/login/init', {
+      method: 'POST',
+      body: request,
+      apiOptions: options,
+    })
+
+    return response.json()
+  }
+
+  /**
+   * Completes user login by sending the signed login challenge.
+   */
+  static async createUserLogin(
+    request: CreateUserLoginRequest,
+    options: DfnsBaseApiOptions
+  ): Promise<UserLoginResponse> {
+    const response = await simpleFetch('/auth/login', {
+      method: 'POST',
+      body: request,
+      apiOptions: options,
+    })
+
+    return response.json()
+  }
+  /**
+   * Completes user logout by sending the user auth token.
+   */
+  static async userLogout(
+    options: DfnsBaseApiOptions
+  ): Promise<void> {
+    if (!options.authToken) {
+      throw new Error('authToken is required')
+    }
+    const response = await simpleFetch('/auth/logout', {
+      method: 'PUT',
+      apiOptions: options,
+    })
+
+    return response.json()
+  }
+
+  /**
+   * Initiates Registration by creating a challenge that will need to be signed by a new set of Credentials.
+   */
+  static async createUserRegistrationChallenge(
+    request: CreateUserRegistrationChallengeRequest,
+    options: DfnsBaseApiOptions
+  ): Promise<UserRegistrationChallengeResponse> {
+    const response = await simpleFetch('/auth/registration/init', {
+      method: 'POST',
+      body: request,
+      apiOptions: options,
+    })
+
+    return response.json()
+  }
+
+  /**
+   * Completes Registration by sending the signed registration challenge, containing the new Credential identity created.
+   */
+  static async createUserRegistration(
+    request: CreateUserRegistrationRequest,
+    options: DfnsBaseApiOptions
+  ): Promise<UserRegistrationResponse> {
+    const response = await simpleFetch('/auth/registration', {
+      method: 'POST',
+      body: request,
+      apiOptions: options,
+    })
+
+    return response.json()
+  }
+
+  /**
+   * Completes Recovery by sending the signed recovery challenge, containing the new Credential identity created.
+   */
+  async createUserRecovery(
+    request: CreateUserRecoveryRequest,
+    options: DfnsBaseApiOptions
+  ): Promise<UserRecoveryResponse> {
+    const response = await simpleFetch('/auth/recover/user', {
+      method: 'POST',
+      body: request,
+      apiOptions: options,
+    })
+
+    return response.json()
+  }
+}

package/codegen/Assets/AssetsClient.ts

@@ -0,0 +1,137 @@
+import { DfnsApiClientOptions } from '../../dfnsApiClient'
+import { simpleFetch, userActionFetch } from '../../utils/fetch'
+import { buildPathAndQuery } from '../../utils/url'
+import * as T from './types'
+
+export class AssetsClient {
+  constructor(private apiOptions: DfnsApiClientOptions) {}
+
+  async initiatePayment(
+    request: T.InitiatePaymentRequest
+  ): Promise<T.InitiatePaymentResponse> {
+    const path = buildPathAndQuery(
+      '/assets/asset-accounts/:assetAccountId/payments',
+      {
+        path: { assetAccountId: request.assetAccountId },
+        query: {},
+      }
+    )
+
+    const response = await userActionFetch(path, {
+      method: 'POST',
+      body: request.body,
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async getPaymentById(
+    request: T.GetPaymentByIdRequest
+  ): Promise<T.GetPaymentByIdResponse> {
+    const path = buildPathAndQuery(
+      '/assets/asset-accounts/:assetAccountId/payments/:paymentId',
+      {
+        path: {
+          assetAccountId: request.assetAccountId,
+          paymentId: request.paymentId,
+        },
+        query: {},
+      }
+    )
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async listPayments(
+    request: T.ListPaymentsRequest
+  ): Promise<T.ListPaymentsResponse> {
+    const path = buildPathAndQuery(
+      '/assets/asset-accounts/:assetAccountId/payments',
+      {
+        path: { assetAccountId: request.assetAccountId },
+        query: {},
+      }
+    )
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async createAssetAccount(
+    request: T.CreateAssetAccountRequest
+  ): Promise<T.CreateAssetAccountResponse> {
+    const path = buildPathAndQuery('/assets/asset-accounts', {
+      path: {},
+      query: {},
+    })
+
+    const response = await userActionFetch(path, {
+      method: 'POST',
+      body: request.body,
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async getAssetAccountById(
+    request: T.GetAssetAccountByIdRequest
+  ): Promise<T.GetAssetAccountByIdResponse> {
+    const path = buildPathAndQuery('/assets/asset-accounts/:assetAccountId', {
+      path: { assetAccountId: request.assetAccountId },
+      query: {},
+    })
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async listAssetAccounts(
+    request: T.ListAssetAccountsRequest
+  ): Promise<T.ListAssetAccountsResponse> {
+    const path = buildPathAndQuery('/assets/asset-accounts', {
+      path: {},
+      query: request.query ?? {},
+    })
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async getAssetAccountBalanceById(
+    request: T.GetAssetAccountBalanceByIdRequest
+  ): Promise<T.GetAssetAccountBalanceByIdResponse> {
+    const path = buildPathAndQuery(
+      '/assets/asset-accounts/:assetAccountId/balance',
+      {
+        path: { assetAccountId: request.assetAccountId },
+        query: {},
+      }
+    )
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+}

package/codegen/Assets/DelegatedAssetsClient.ts

@@ -0,0 +1,201 @@
+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 DelegatedAssetsClient {
+  constructor(private apiOptions: DfnsDelegatedApiClientOptions) {}
+
+  async initiatePaymentInit(
+    request: T.InitiatePaymentRequest
+  ): Promise<UserActionChallengeResponse> {
+    const path = buildPathAndQuery(
+      '/assets/asset-accounts/:assetAccountId/payments',
+      {
+        path: { assetAccountId: request.assetAccountId },
+        query: {},
+      }
+    )
+
+    const challenge = await BaseAuthApi.createUserActionChallenge(
+      {
+        userActionHttpMethod: 'POST',
+        userActionHttpPath: path,
+        userActionPayload: JSON.stringify(request.body),
+        userActionServerKind: 'Api',
+      },
+      this.apiOptions
+    )
+
+    return challenge
+  }
+
+  async initiatePaymentComplete(
+    request: T.InitiatePaymentRequest,
+    signedChallenge: SignUserActionChallengeRequest
+  ): Promise<T.InitiatePaymentResponse> {
+    const path = buildPathAndQuery(
+      '/assets/asset-accounts/:assetAccountId/payments',
+      {
+        path: { assetAccountId: request.assetAccountId },
+        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 getPaymentById(
+    request: T.GetPaymentByIdRequest
+  ): Promise<T.GetPaymentByIdResponse> {
+    const path = buildPathAndQuery(
+      '/assets/asset-accounts/:assetAccountId/payments/:paymentId',
+      {
+        path: {
+          assetAccountId: request.assetAccountId,
+          paymentId: request.paymentId,
+        },
+        query: {},
+      }
+    )
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async listPayments(
+    request: T.ListPaymentsRequest
+  ): Promise<T.ListPaymentsResponse> {
+    const path = buildPathAndQuery(
+      '/assets/asset-accounts/:assetAccountId/payments',
+      {
+        path: { assetAccountId: request.assetAccountId },
+        query: {},
+      }
+    )
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async createAssetAccountInit(
+    request: T.CreateAssetAccountRequest
+  ): Promise<UserActionChallengeResponse> {
+    const path = buildPathAndQuery('/assets/asset-accounts', {
+      path: {},
+      query: {},
+    })
+
+    const challenge = await BaseAuthApi.createUserActionChallenge(
+      {
+        userActionHttpMethod: 'POST',
+        userActionHttpPath: path,
+        userActionPayload: JSON.stringify(request.body),
+        userActionServerKind: 'Api',
+      },
+      this.apiOptions
+    )
+
+    return challenge
+  }
+
+  async createAssetAccountComplete(
+    request: T.CreateAssetAccountRequest,
+    signedChallenge: SignUserActionChallengeRequest
+  ): Promise<T.CreateAssetAccountResponse> {
+    const path = buildPathAndQuery('/assets/asset-accounts', {
+      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 getAssetAccountById(
+    request: T.GetAssetAccountByIdRequest
+  ): Promise<T.GetAssetAccountByIdResponse> {
+    const path = buildPathAndQuery('/assets/asset-accounts/:assetAccountId', {
+      path: { assetAccountId: request.assetAccountId },
+      query: {},
+    })
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async listAssetAccounts(
+    request: T.ListAssetAccountsRequest
+  ): Promise<T.ListAssetAccountsResponse> {
+    const path = buildPathAndQuery('/assets/asset-accounts', {
+      path: {},
+      query: request.query ?? {},
+    })
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async getAssetAccountBalanceById(
+    request: T.GetAssetAccountBalanceByIdRequest
+  ): Promise<T.GetAssetAccountBalanceByIdResponse> {
+    const path = buildPathAndQuery(
+      '/assets/asset-accounts/:assetAccountId/balance',
+      {
+        path: { assetAccountId: request.assetAccountId },
+        query: {},
+      }
+    )
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+}

package/codegen/Assets/index.ts

@@ -0,0 +1,3 @@
+export * from './AssetsClient'
+export * from './DelegatedAssetsClient'
+export * from './types'

package/codegen/Assets/types.ts

@@ -0,0 +1,45 @@
+import * as Assets from '../datamodel/Assets'
+
+export type InitiatePaymentRequest = {
+  assetAccountId: string
+  body: Assets.CreatePaymentInput
+}
+
+export type InitiatePaymentResponse = Assets.Payment
+
+export type GetPaymentByIdRequest = {
+  assetAccountId: string
+  paymentId: string
+}
+
+export type GetPaymentByIdResponse = Assets.Payment
+
+export type ListPaymentsRequest = {
+  assetAccountId: string
+}
+
+export type ListPaymentsResponse = { items: Assets.Payment[] }
+
+export type CreateAssetAccountRequest = {
+  body: Assets.CreateAssetAccountInput
+}
+
+export type CreateAssetAccountResponse = Assets.AssetAccount
+
+export type GetAssetAccountByIdRequest = {
+  assetAccountId: string
+}
+
+export type GetAssetAccountByIdResponse = Assets.AssetAccount
+
+export type ListAssetAccountsRequest = {
+  query?: { status?: Assets.AssetAccountStatus }
+}
+
+export type ListAssetAccountsResponse = { items: Assets.AssetAccount[] }
+
+export type GetAssetAccountBalanceByIdRequest = {
+  assetAccountId: string
+}
+
+export type GetAssetAccountBalanceByIdResponse = Assets.AssetAccountBalance