@dfns/sdk 0.2.1 → 0.2.3-rc.1

package/codegen/PolicyManagement/PolicyManagementClient.ts

@@ -0,0 +1,205 @@
+import { DfnsApiClientOptions } from '../../dfnsApiClient'
+import { simpleFetch, userActionFetch } from '../../utils/fetch'
+import { buildPathAndQuery } from '../../utils/url'
+import * as T from './types'
+
+export class PolicyManagementClient {
+  constructor(private apiOptions: DfnsApiClientOptions) {}
+
+  async createPolicy(
+    request: T.CreatePolicyRequest
+  ): Promise<T.CreatePolicyResponse> {
+    const path = buildPathAndQuery('/policies', {
+      path: {},
+      query: {},
+    })
+
+    const response = await userActionFetch(path, {
+      method: 'POST',
+      body: request.body,
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async getPolicyById(
+    request: T.GetPolicyByIdRequest
+  ): Promise<T.GetPolicyByIdResponse> {
+    const path = buildPathAndQuery('/policies/:policyId', {
+      path: { policyId: request.policyId },
+      query: {},
+    })
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async listPolicies(): Promise<T.ListPoliciesResponse> {
+    const path = buildPathAndQuery('/policies', {
+      path: {},
+      query: {},
+    })
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async archivePolicy(
+    request: T.ArchivePolicyRequest
+  ): Promise<T.ArchivePolicyResponse> {
+    const path = buildPathAndQuery('/policies/:policyId', {
+      path: { policyId: request.policyId },
+      query: {},
+    })
+
+    const response = await userActionFetch(path, {
+      method: 'DELETE',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async createPolicyControl(
+    request: T.CreatePolicyControlRequest
+  ): Promise<T.CreatePolicyControlResponse> {
+    const path = buildPathAndQuery('/policies/policy-controls', {
+      path: {},
+      query: {},
+    })
+
+    const response = await userActionFetch(path, {
+      method: 'POST',
+      body: request.body,
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async getPolicyControlById(
+    request: T.GetPolicyControlByIdRequest
+  ): Promise<T.GetPolicyControlByIdResponse> {
+    const path = buildPathAndQuery(
+      '/policies/policy-controls/:policyControlId',
+      {
+        path: { policyControlId: request.policyControlId },
+        query: {},
+      }
+    )
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async listPolicyControls(): Promise<T.ListPolicyControlsResponse> {
+    const path = buildPathAndQuery('/policies/policy-controls', {
+      path: {},
+      query: {},
+    })
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async archivePolicyControl(
+    request: T.ArchivePolicyControlRequest
+  ): Promise<T.ArchivePolicyControlResponse> {
+    const path = buildPathAndQuery(
+      '/policies/policy-controls/:policyControlId',
+      {
+        path: { policyControlId: request.policyControlId },
+        query: {},
+      }
+    )
+
+    const response = await userActionFetch(path, {
+      method: 'DELETE',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async createPolicyRule(
+    request: T.CreatePolicyRuleRequest
+  ): Promise<T.CreatePolicyRuleResponse> {
+    const path = buildPathAndQuery('/policies/policy-rules', {
+      path: {},
+      query: {},
+    })
+
+    const response = await userActionFetch(path, {
+      method: 'POST',
+      body: request.body,
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async getPolicyRuleById(
+    request: T.GetPolicyRuleByIdRequest
+  ): Promise<T.GetPolicyRuleByIdResponse> {
+    const path = buildPathAndQuery('/policies/policy-rules/:policyRuleId', {
+      path: { policyRuleId: request.policyRuleId },
+      query: {},
+    })
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async listPolicyRules(
+    request: T.ListPolicyRulesRequest
+  ): Promise<T.ListPolicyRulesResponse> {
+    const path = buildPathAndQuery('/policies/policy-rules', {
+      path: {},
+      query: request.query ?? {},
+    })
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async archivePolicyRule(
+    request: T.ArchivePolicyRuleRequest
+  ): Promise<T.ArchivePolicyRuleResponse> {
+    const path = buildPathAndQuery('/policies/policy-rules/:policyRuleId', {
+      path: { policyRuleId: request.policyRuleId },
+      query: {},
+    })
+
+    const response = await userActionFetch(path, {
+      method: 'DELETE',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+}

package/codegen/PolicyManagement/index.ts

@@ -0,0 +1,3 @@
+export * from './DelegatedPolicyManagementClient'
+export * from './PolicyManagementClient'
+export * from './types'

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

@@ -1,51 +1,67 @@
-import * as PolicyManagement from '../datamodel/PolicyManagement';
+import * as PolicyManagement from '../datamodel/PolicyManagement'
+
 export type CreatePolicyRequest = {
-    body: PolicyManagement.CreatePolicyInput;
-};
-export type CreatePolicyResponse = PolicyManagement.Policy;
+  body: PolicyManagement.CreatePolicyInput
+}
+
+export type CreatePolicyResponse = PolicyManagement.Policy
+
 export type GetPolicyByIdRequest = {
-    policyId: string;
-};
-export type GetPolicyByIdResponse = PolicyManagement.Policy;
-export type ListPoliciesResponse = {
-    items: PolicyManagement.Policy[];
-};
+  policyId: string
+}
+
+export type GetPolicyByIdResponse = PolicyManagement.Policy
+
+export type ListPoliciesResponse = { items: PolicyManagement.Policy[] }
+
 export type ArchivePolicyRequest = {
-    policyId: string;
-};
-export type ArchivePolicyResponse = PolicyManagement.Policy;
+  policyId: string
+}
+
+export type ArchivePolicyResponse = PolicyManagement.Policy
+
 export type CreatePolicyControlRequest = {
-    body: PolicyManagement.CreatePolicyControlInput;
-};
-export type CreatePolicyControlResponse = PolicyManagement.PolicyControl;
+  body: PolicyManagement.CreatePolicyControlInput
+}
+
+export type CreatePolicyControlResponse = PolicyManagement.PolicyControl
+
 export type GetPolicyControlByIdRequest = {
-    policyControlId: string;
-};
-export type GetPolicyControlByIdResponse = PolicyManagement.PolicyControl;
+  policyControlId: string
+}
+
+export type GetPolicyControlByIdResponse = PolicyManagement.PolicyControl
+
 export type ListPolicyControlsResponse = {
-    items: PolicyManagement.PolicyControl[];
-};
+  items: PolicyManagement.PolicyControl[]
+}
+
 export type ArchivePolicyControlRequest = {
-    policyControlId: string;
-};
-export type ArchivePolicyControlResponse = PolicyManagement.PolicyControl;
+  policyControlId: string
+}
+
+export type ArchivePolicyControlResponse = PolicyManagement.PolicyControl
+
 export type CreatePolicyRuleRequest = {
-    body: PolicyManagement.CreatePolicyRuleInput;
-};
-export type CreatePolicyRuleResponse = PolicyManagement.PolicyRule;
+  body: PolicyManagement.CreatePolicyRuleInput
+}
+
+export type CreatePolicyRuleResponse = PolicyManagement.PolicyRule
+
 export type GetPolicyRuleByIdRequest = {
-    policyRuleId: string;
-};
-export type GetPolicyRuleByIdResponse = PolicyManagement.PolicyRule;
+  policyRuleId: string
+}
+
+export type GetPolicyRuleByIdResponse = PolicyManagement.PolicyRule
+
 export type ListPolicyRulesRequest = {
-    query?: {
-        author?: string;
-    };
-};
-export type ListPolicyRulesResponse = {
-    items: PolicyManagement.PolicyRule[];
-};
+  query?: { author?: string }
+}
+
+export type ListPolicyRulesResponse = { items: PolicyManagement.PolicyRule[] }
+
 export type ArchivePolicyRuleRequest = {
-    policyRuleId: string;
-};
-export type ArchivePolicyRuleResponse = PolicyManagement.PolicyRule;
+  policyRuleId: string
+}
+
+export type ArchivePolicyRuleResponse = PolicyManagement.PolicyRule

package/codegen/PublicKeys/DelegatedPublicKeysClient.ts

@@ -0,0 +1,299 @@
+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 DelegatedPublicKeysClient {
+  constructor(private apiOptions: DfnsDelegatedApiClientOptions) {}
+
+  async getPublicKeyById(
+    request: T.GetPublicKeyByIdRequest
+  ): Promise<T.GetPublicKeyByIdResponse> {
+    const path = buildPathAndQuery('/public-keys/:publicKeyId', {
+      path: { publicKeyId: request.publicKeyId },
+      query: {},
+    })
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async createPublicKeyInit(
+    request: T.CreatePublicKeyRequest
+  ): Promise<UserActionChallengeResponse> {
+    const path = buildPathAndQuery('/public-keys', {
+      path: {},
+      query: {},
+    })
+
+    const challenge = await BaseAuthApi.createUserActionChallenge(
+      {
+        userActionHttpMethod: 'POST',
+        userActionHttpPath: path,
+        userActionPayload: JSON.stringify(request.body),
+        userActionServerKind: 'Api',
+      },
+      this.apiOptions
+    )
+
+    return challenge
+  }
+
+  async createPublicKeyComplete(
+    request: T.CreatePublicKeyRequest,
+    signedChallenge: SignUserActionChallengeRequest
+  ): Promise<T.CreatePublicKeyResponse> {
+    const path = buildPathAndQuery('/public-keys', {
+      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 listPublicKeys(): Promise<T.ListPublicKeysResponse> {
+    const path = buildPathAndQuery('/public-keys', {
+      path: {},
+      query: {},
+    })
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async getAddressForNetwork(
+    request: T.GetAddressForNetworkRequest
+  ): Promise<T.GetAddressForNetworkResponse> {
+    const path = buildPathAndQuery('/public-keys/:publicKeyId/address', {
+      path: { publicKeyId: request.publicKeyId },
+      query: request.query ?? {},
+    })
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async getSignatureById(
+    request: T.GetSignatureByIdRequest
+  ): Promise<T.GetSignatureByIdResponse> {
+    const path = buildPathAndQuery(
+      '/public-keys/:publicKeyId/signatures/:signatureId',
+      {
+        path: {
+          publicKeyId: request.publicKeyId,
+          signatureId: request.signatureId,
+        },
+        query: {},
+      }
+    )
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async createSignatureInit(
+    request: T.CreateSignatureRequest
+  ): Promise<UserActionChallengeResponse> {
+    const path = buildPathAndQuery('/public-keys/:publicKeyId/signatures', {
+      path: { publicKeyId: request.publicKeyId },
+      query: {},
+    })
+
+    const challenge = await BaseAuthApi.createUserActionChallenge(
+      {
+        userActionHttpMethod: 'POST',
+        userActionHttpPath: path,
+        userActionPayload: JSON.stringify(request.body),
+        userActionServerKind: 'Api',
+      },
+      this.apiOptions
+    )
+
+    return challenge
+  }
+
+  async createSignatureComplete(
+    request: T.CreateSignatureRequest,
+    signedChallenge: SignUserActionChallengeRequest
+  ): Promise<T.CreateSignatureResponse> {
+    const path = buildPathAndQuery('/public-keys/:publicKeyId/signatures', {
+      path: { publicKeyId: request.publicKeyId },
+      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 startWalletConnectSessionInit(
+    request: T.StartWalletConnectSessionRequest
+  ): Promise<UserActionChallengeResponse> {
+    const path = buildPathAndQuery(
+      '/public-keys/:publicKeyId/walletconnect-session',
+      {
+        path: { publicKeyId: request.publicKeyId },
+        query: {},
+      }
+    )
+
+    const challenge = await BaseAuthApi.createUserActionChallenge(
+      {
+        userActionHttpMethod: 'POST',
+        userActionHttpPath: path,
+        userActionPayload: JSON.stringify(request.body),
+        userActionServerKind: 'Api',
+      },
+      this.apiOptions
+    )
+
+    return challenge
+  }
+
+  async startWalletConnectSessionComplete(
+    request: T.StartWalletConnectSessionRequest,
+    signedChallenge: SignUserActionChallengeRequest
+  ): Promise<T.StartWalletConnectSessionResponse> {
+    const path = buildPathAndQuery(
+      '/public-keys/:publicKeyId/walletconnect-session',
+      {
+        path: { publicKeyId: request.publicKeyId },
+        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 listTransactions(
+    request: T.ListTransactionsRequest
+  ): Promise<T.ListTransactionsResponse> {
+    const path = buildPathAndQuery('/public-keys/:publicKeyId/transactions', {
+      path: { publicKeyId: request.publicKeyId },
+      query: request.query ?? {},
+    })
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async createTransactionInit(
+    request: T.CreateTransactionRequest
+  ): Promise<UserActionChallengeResponse> {
+    const path = buildPathAndQuery('/public-keys/transactions', {
+      path: {},
+      query: {},
+    })
+
+    const challenge = await BaseAuthApi.createUserActionChallenge(
+      {
+        userActionHttpMethod: 'POST',
+        userActionHttpPath: path,
+        userActionPayload: JSON.stringify(request.body),
+        userActionServerKind: 'Api',
+      },
+      this.apiOptions
+    )
+
+    return challenge
+  }
+
+  async createTransactionComplete(
+    request: T.CreateTransactionRequest,
+    signedChallenge: SignUserActionChallengeRequest
+  ): Promise<T.CreateTransactionResponse> {
+    const path = buildPathAndQuery('/public-keys/transactions', {
+      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 getTransactionById(
+    request: T.GetTransactionByIdRequest
+  ): Promise<T.GetTransactionByIdResponse> {
+    const path = buildPathAndQuery('/public-keys/transactions/:transactionId', {
+      path: { transactionId: request.transactionId },
+      query: {},
+    })
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+}