@dfns/sdk 0.2.2 → 0.2.3-rc.1

package/codegen/Permissions/types.ts

@@ -0,0 +1,82 @@
+import * as Permissions from '../datamodel/Permissions'
+
+export type CreatePermissionRequest = {
+  body: Permissions.CreatePermissionInput
+}
+
+export type CreatePermissionResponse = Permissions.Permission
+
+export type UpdatePermissionRequest = {
+  permissionId: string
+  body: Permissions.UpdatePermissionInput
+}
+
+export type UpdatePermissionResponse = Permissions.Permission
+
+export type ArchivePermissionRequest = {
+  permissionId: string
+  body: Permissions.ArchivePermissionInput
+}
+
+export type ArchivePermissionResponse = Permissions.Permission
+
+export type GetPermissionByIdRequest = {
+  permissionId: string
+}
+
+export type GetPermissionByIdResponse = Permissions.Permission
+
+export type ListPermissionsResponse = { items: Permissions.Permission[] }
+
+export type CreatePermissionPredicateRequest = {
+  permissionId: string
+  body: Permissions.CreatePermissionPredicateInput
+}
+
+export type CreatePermissionPredicateResponse = Permissions.PermissionPredicate
+
+export type UpdatePermissionPredicateRequest = {
+  permissionId: string
+  predicateId: string
+  body: Permissions.UpdatePermissionPredicateInput
+}
+
+export type UpdatePermissionPredicateResponse = Permissions.PermissionPredicate
+
+export type ArchivePermissionPredicateRequest = {
+  permissionId: string
+  predicateId: string
+  body: Permissions.ArchivePermissionPredicateInput
+}
+
+export type ArchivePermissionPredicateResponse = Permissions.PermissionPredicate
+
+export type ListPermissionPredicatesRequest = {
+  permissionId: string
+}
+
+export type ListPermissionPredicatesResponse = {
+  items: Permissions.PermissionPredicate[]
+}
+
+export type CreatePermissionAssignmentRequest = {
+  body: Permissions.CreatePermissionAssignmentInput
+}
+
+export type CreatePermissionAssignmentResponse =
+  Permissions.PermissionAssignment
+
+export type RevokePermissionAssignmentRequest = {
+  assignmentId: string
+}
+
+export type RevokePermissionAssignmentResponse =
+  Permissions.DeletionAcknowledgement
+
+export type ListPermissionAssignmentsRequest = {
+  query?: { permissionId?: string; identityId?: string }
+}
+
+export type ListPermissionAssignmentsResponse = {
+  items: Permissions.PermissionAssignment[]
+}

package/codegen/PolicyExecution/DelegatedPolicyExecutionClient.ts

@@ -0,0 +1,99 @@
+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 DelegatedPolicyExecutionClient {
+  constructor(private apiOptions: DfnsDelegatedApiClientOptions) {}
+
+  async listPolicyControlExecutions(
+    request: T.ListPolicyControlExecutionsRequest
+  ): Promise<T.ListPolicyControlExecutionsResponse> {
+    const path = buildPathAndQuery('/policies/policy-control-executions', {
+      path: {},
+      query: request.query ?? {},
+    })
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async getPolicyControlExecutionById(
+    request: T.GetPolicyControlExecutionByIdRequest
+  ): Promise<T.GetPolicyControlExecutionByIdResponse> {
+    const path = buildPathAndQuery(
+      '/policies/policy-control-executions/:policyControlExecutionId',
+      {
+        path: { policyControlExecutionId: request.policyControlExecutionId },
+        query: {},
+      }
+    )
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async updatePolicyControlExecutionInit(
+    request: T.UpdatePolicyControlExecutionRequest
+  ): Promise<UserActionChallengeResponse> {
+    const path = buildPathAndQuery(
+      '/policies/policy-control-executions/:policyControlExecutionId',
+      {
+        path: { policyControlExecutionId: request.policyControlExecutionId },
+        query: {},
+      }
+    )
+
+    const challenge = await BaseAuthApi.createUserActionChallenge(
+      {
+        userActionHttpMethod: 'PUT',
+        userActionHttpPath: path,
+        userActionPayload: JSON.stringify(request.body),
+        userActionServerKind: 'Api',
+      },
+      this.apiOptions
+    )
+
+    return challenge
+  }
+
+  async updatePolicyControlExecutionComplete(
+    request: T.UpdatePolicyControlExecutionRequest,
+    signedChallenge: SignUserActionChallengeRequest
+  ): Promise<T.UpdatePolicyControlExecutionResponse> {
+    const path = buildPathAndQuery(
+      '/policies/policy-control-executions/:policyControlExecutionId',
+      {
+        path: { policyControlExecutionId: request.policyControlExecutionId },
+        query: {},
+      }
+    )
+
+    const { userAction } = await BaseAuthApi.signUserActionChallenge(
+      signedChallenge,
+      this.apiOptions
+    )
+
+    const response = await simpleFetch(path, {
+      method: 'PUT',
+      body: request.body,
+      headers: { 'x-dfns-useraction': userAction },
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+}

package/codegen/PolicyExecution/PolicyExecutionClient.ts

@@ -0,0 +1,63 @@
+import { DfnsApiClientOptions } from '../../dfnsApiClient'
+import { simpleFetch, userActionFetch } from '../../utils/fetch'
+import { buildPathAndQuery } from '../../utils/url'
+import * as T from './types'
+
+export class PolicyExecutionClient {
+  constructor(private apiOptions: DfnsApiClientOptions) {}
+
+  async listPolicyControlExecutions(
+    request: T.ListPolicyControlExecutionsRequest
+  ): Promise<T.ListPolicyControlExecutionsResponse> {
+    const path = buildPathAndQuery('/policies/policy-control-executions', {
+      path: {},
+      query: request.query ?? {},
+    })
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async getPolicyControlExecutionById(
+    request: T.GetPolicyControlExecutionByIdRequest
+  ): Promise<T.GetPolicyControlExecutionByIdResponse> {
+    const path = buildPathAndQuery(
+      '/policies/policy-control-executions/:policyControlExecutionId',
+      {
+        path: { policyControlExecutionId: request.policyControlExecutionId },
+        query: {},
+      }
+    )
+
+    const response = await simpleFetch(path, {
+      method: 'GET',
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+
+  async updatePolicyControlExecution(
+    request: T.UpdatePolicyControlExecutionRequest
+  ): Promise<T.UpdatePolicyControlExecutionResponse> {
+    const path = buildPathAndQuery(
+      '/policies/policy-control-executions/:policyControlExecutionId',
+      {
+        path: { policyControlExecutionId: request.policyControlExecutionId },
+        query: {},
+      }
+    )
+
+    const response = await userActionFetch(path, {
+      method: 'PUT',
+      body: request.body,
+      apiOptions: this.apiOptions,
+    })
+
+    return response.json()
+  }
+}

package/codegen/PolicyExecution/index.ts

@@ -0,0 +1,3 @@
+export * from './DelegatedPolicyExecutionClient'
+export * from './PolicyExecutionClient'
+export * from './types'

package/codegen/PolicyExecution/types.ts

@@ -0,0 +1,24 @@
+import * as PolicyExecution from '../datamodel/PolicyExecution'
+
+export type ListPolicyControlExecutionsRequest = {
+  query?: { activityId: string }
+}
+
+export type ListPolicyControlExecutionsResponse = {
+  items: PolicyExecution.PolicyControlExecution[]
+}
+
+export type GetPolicyControlExecutionByIdRequest = {
+  policyControlExecutionId: string
+}
+
+export type GetPolicyControlExecutionByIdResponse =
+  PolicyExecution.PolicyControlExecution
+
+export type UpdatePolicyControlExecutionRequest = {
+  policyControlExecutionId: string
+  body: PolicyExecution.UpdatePolicyControlExecutionInput
+}
+
+export type UpdatePolicyControlExecutionResponse =
+  PolicyExecution.PolicyControlExecution

package/codegen/PolicyManagement/DelegatedPolicyManagementClient.ts

@@ -0,0 +1,384 @@
+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 DelegatedPolicyManagementClient {
+  constructor(private apiOptions: DfnsDelegatedApiClientOptions) {}
+
+  async createPolicyInit(
+    request: T.CreatePolicyRequest
+  ): Promise<UserActionChallengeResponse> {
+    const path = buildPathAndQuery('/policies', {
+      path: {},
+      query: {},
+    })
+
+    const challenge = await BaseAuthApi.createUserActionChallenge(
+      {
+        userActionHttpMethod: 'POST',
+        userActionHttpPath: path,
+        userActionPayload: JSON.stringify(request.body),
+        userActionServerKind: 'Api',
+      },
+      this.apiOptions
+    )
+
+    return challenge
+  }
+
+  async createPolicyComplete(
+    request: T.CreatePolicyRequest,
+    signedChallenge: SignUserActionChallengeRequest
+  ): Promise<T.CreatePolicyResponse> {
+    const path = buildPathAndQuery('/policies', {
+      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 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 archivePolicyInit(
+    request: T.ArchivePolicyRequest
+  ): Promise<UserActionChallengeResponse> {
+    const path = buildPathAndQuery('/policies/:policyId', {
+      path: { policyId: request.policyId },
+      query: {},
+    })
+
+    const challenge = await BaseAuthApi.createUserActionChallenge(
+      {
+        userActionHttpMethod: 'DELETE',
+        userActionHttpPath: path,
+        userActionPayload: JSON.stringify({}),
+        userActionServerKind: 'Api',
+      },
+      this.apiOptions
+    )
+
+    return challenge
+  }
+
+  async archivePolicyComplete(
+    request: T.ArchivePolicyRequest,
+    signedChallenge: SignUserActionChallengeRequest
+  ): Promise<T.ArchivePolicyResponse> {
+    const path = buildPathAndQuery('/policies/:policyId', {
+      path: { policyId: request.policyId },
+      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 createPolicyControlInit(
+    request: T.CreatePolicyControlRequest
+  ): Promise<UserActionChallengeResponse> {
+    const path = buildPathAndQuery('/policies/policy-controls', {
+      path: {},
+      query: {},
+    })
+
+    const challenge = await BaseAuthApi.createUserActionChallenge(
+      {
+        userActionHttpMethod: 'POST',
+        userActionHttpPath: path,
+        userActionPayload: JSON.stringify(request.body),
+        userActionServerKind: 'Api',
+      },
+      this.apiOptions
+    )
+
+    return challenge
+  }
+
+  async createPolicyControlComplete(
+    request: T.CreatePolicyControlRequest,
+    signedChallenge: SignUserActionChallengeRequest
+  ): Promise<T.CreatePolicyControlResponse> {
+    const path = buildPathAndQuery('/policies/policy-controls', {
+      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 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 archivePolicyControlInit(
+    request: T.ArchivePolicyControlRequest
+  ): Promise<UserActionChallengeResponse> {
+    const path = buildPathAndQuery(
+      '/policies/policy-controls/:policyControlId',
+      {
+        path: { policyControlId: request.policyControlId },
+        query: {},
+      }
+    )
+
+    const challenge = await BaseAuthApi.createUserActionChallenge(
+      {
+        userActionHttpMethod: 'DELETE',
+        userActionHttpPath: path,
+        userActionPayload: JSON.stringify({}),
+        userActionServerKind: 'Api',
+      },
+      this.apiOptions
+    )
+
+    return challenge
+  }
+
+  async archivePolicyControlComplete(
+    request: T.ArchivePolicyControlRequest,
+    signedChallenge: SignUserActionChallengeRequest
+  ): Promise<T.ArchivePolicyControlResponse> {
+    const path = buildPathAndQuery(
+      '/policies/policy-controls/:policyControlId',
+      {
+        path: { policyControlId: request.policyControlId },
+        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 createPolicyRuleInit(
+    request: T.CreatePolicyRuleRequest
+  ): Promise<UserActionChallengeResponse> {
+    const path = buildPathAndQuery('/policies/policy-rules', {
+      path: {},
+      query: {},
+    })
+
+    const challenge = await BaseAuthApi.createUserActionChallenge(
+      {
+        userActionHttpMethod: 'POST',
+        userActionHttpPath: path,
+        userActionPayload: JSON.stringify(request.body),
+        userActionServerKind: 'Api',
+      },
+      this.apiOptions
+    )
+
+    return challenge
+  }
+
+  async createPolicyRuleComplete(
+    request: T.CreatePolicyRuleRequest,
+    signedChallenge: SignUserActionChallengeRequest
+  ): Promise<T.CreatePolicyRuleResponse> {
+    const path = buildPathAndQuery('/policies/policy-rules', {
+      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 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 archivePolicyRuleInit(
+    request: T.ArchivePolicyRuleRequest
+  ): Promise<UserActionChallengeResponse> {
+    const path = buildPathAndQuery('/policies/policy-rules/:policyRuleId', {
+      path: { policyRuleId: request.policyRuleId },
+      query: {},
+    })
+
+    const challenge = await BaseAuthApi.createUserActionChallenge(
+      {
+        userActionHttpMethod: 'DELETE',
+        userActionHttpPath: path,
+        userActionPayload: JSON.stringify({}),
+        userActionServerKind: 'Api',
+      },
+      this.apiOptions
+    )
+
+    return challenge
+  }
+
+  async archivePolicyRuleComplete(
+    request: T.ArchivePolicyRuleRequest,
+    signedChallenge: SignUserActionChallengeRequest
+  ): Promise<T.ArchivePolicyRuleResponse> {
+    const path = buildPathAndQuery('/policies/policy-rules/:policyRuleId', {
+      path: { policyRuleId: request.policyRuleId },
+      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()
+  }
+}