server/http/openapi/management-routes/applications-authorization.ts
Rama main · réplica de lectura del repositorio original.
import {
createApiResourceSchema,
resourceServerSchema,
resourceServersResponseSchema,
updateApiResourceSchema,
} from '@shared/api/agent-api'
import {
apiResourceContractResponseSchema,
createApplicationPermissionRequestSchema,
createUserPermissionRequestSchema,
listApplicationPermissionsResponseSchema,
listAuthorizedResourceServersQuerySchema,
listAuthorizedResourceServersResponseSchema,
listPermissionsQuerySchema,
listUserPermissionsResponseSchema,
permissionResponseSchema,
} from '@shared/api/authorization'
import {
addMemberRequestSchema,
applicationAuthorizationParam,
applicationAuthorizationSchema,
applicationIdParam,
applicationResponseSchema,
createApplicationRequestSchema,
createApplicationResponseSchema,
createInvitationRequestSchema,
createManagementFederatedCredentialRequestSchema,
createManagementFederatedCredentialResponseSchema,
createOrganizationRequestSchema,
createRoleRequestSchema,
federatedCredentialParam,
invitationParam,
invitationResponseSchema,
jsonBody,
listApiResourcesQuerySchema,
listApplicationAuthorizationsQuerySchema,
listApplicationAuthorizationsResponseSchema,
listApplicationsQuerySchema,
listApplicationsResponseSchema,
listClientSecretsResponseSchema,
listInvitationsResponseSchema,
listManagementFederatedCredentialsResponseSchema,
listMembersResponseSchema,
listOrganizationsResponseSchema,
listRedirectUrisResponseSchema,
listRolesResponseSchema,
locationResponseHeader,
type ManagementRouteConfig,
memberParam,
memberResponseSchema,
memberRolesResponseSchema,
organizationIdParam,
organizationResponseSchema,
paginationQuerySchema,
replaceMemberRolesRequestSchema,
replaceRedirectUrisRequestSchema,
resourceServerIdParam,
roleKeyParam,
roleResponseSchema,
rotateClientSecretResponseSchema,
updateApplicationRequestSchema,
updateManagementFederatedCredentialRequestSchema,
updateMemberRequestSchema,
updateOrganizationRequestSchema,
updateRoleRequestSchema,
userIdParam,
z,
} from './helpers'
export const applicationAuthorizationRoutes: ManagementRouteConfig[] = [
{
method: 'get',
path: '/applications',
operationId: 'listApplications',
summary: 'List applications',
request: { query: listApplicationsQuerySchema },
response: listApplicationsResponseSchema,
paginated: true,
},
{
method: 'post',
path: '/applications',
operationId: 'createApplication',
summary: 'Create application',
request: { body: jsonBody(createApplicationRequestSchema) },
response: createApplicationResponseSchema,
status: 201,
responseHeaders: locationResponseHeader,
errors: { 400: 'The Application representation is invalid.', 409: 'The Application already exists.' },
},
{
method: 'get',
path: '/applications/{applicationId}/authorizations',
operationId: 'listApplicationAuthorizations',
summary: 'List Application authorizations',
request: { params: applicationIdParam, query: listApplicationAuthorizationsQuerySchema },
response: listApplicationAuthorizationsResponseSchema,
paginated: true,
errors: { 400: 'The collection query is invalid.' },
},
{
method: 'get',
path: '/applications/{applicationId}/authorizations/{authorizationId}',
operationId: 'getApplicationAuthorization',
summary: 'Get an Application authorization',
request: { params: applicationAuthorizationParam },
response: applicationAuthorizationSchema,
errors: { 404: 'The Application authorization was not found.' },
},
{
method: 'delete',
path: '/applications/{applicationId}/authorizations/{authorizationId}',
operationId: 'deleteApplicationAuthorization',
summary: 'Delete an active Application authorization',
request: { params: applicationAuthorizationParam },
noBody: true,
errors: { 404: 'The Application authorization was not found.' },
},
{
method: 'get',
path: '/users/{userId}/application-authorizations',
operationId: 'listUserApplicationAuthorizations',
summary: "List a User's Application authorizations",
request: { params: userIdParam, query: listApplicationAuthorizationsQuerySchema },
response: listApplicationAuthorizationsResponseSchema,
paginated: true,
errors: { 400: 'The collection query is invalid.' },
},
{
method: 'get',
path: '/applications/{applicationId}',
operationId: 'getApplication',
summary: 'Get application',
request: { params: applicationIdParam },
response: applicationResponseSchema,
},
{
method: 'patch',
path: '/applications/{applicationId}',
operationId: 'updateApplication',
summary: 'Update application',
request: { params: applicationIdParam, body: jsonBody(updateApplicationRequestSchema) },
response: applicationResponseSchema,
},
{
method: 'delete',
path: '/applications/{applicationId}',
operationId: 'deleteApplication',
summary: 'Delete application',
request: { params: applicationIdParam },
noBody: true,
},
{
method: 'get',
path: '/applications/{applicationId}/redirect-uris',
operationId: 'listRedirectUris',
summary: 'List application redirect URIs',
request: { params: applicationIdParam, query: paginationQuerySchema },
response: listRedirectUrisResponseSchema,
paginated: true,
},
{
method: 'put',
path: '/applications/{applicationId}/redirect-uris',
operationId: 'replaceRedirectUris',
summary: 'Replace application redirect URIs',
request: { params: applicationIdParam, body: jsonBody(replaceRedirectUrisRequestSchema) },
response: listRedirectUrisResponseSchema,
},
{
method: 'get',
path: '/applications/{applicationId}/client-secrets',
operationId: 'listClientSecrets',
summary: 'List application client secrets',
request: { params: applicationIdParam, query: paginationQuerySchema },
response: listClientSecretsResponseSchema,
paginated: true,
},
{
method: 'post',
path: '/applications/{applicationId}/client-secrets',
operationId: 'createClientSecret',
summary: 'Create an application client secret',
request: { params: applicationIdParam },
response: rotateClientSecretResponseSchema,
status: 201,
},
{
method: 'get',
path: '/applications/{applicationId}/federated-credentials',
operationId: 'listFederatedCredentials',
summary: 'List application federated credentials',
request: { params: applicationIdParam },
response: listManagementFederatedCredentialsResponseSchema,
},
{
method: 'post',
path: '/applications/{applicationId}/federated-credentials',
operationId: 'createFederatedCredential',
summary: 'Create application federated credential',
request: { params: applicationIdParam, body: jsonBody(createManagementFederatedCredentialRequestSchema) },
response: createManagementFederatedCredentialResponseSchema,
status: 201,
},
{
method: 'get',
path: '/applications/{applicationId}/federated-credentials/{credentialId}',
operationId: 'getFederatedCredential',
summary: 'Get application federated credential',
request: { params: federatedCredentialParam },
response: createManagementFederatedCredentialResponseSchema,
},
{
method: 'patch',
path: '/applications/{applicationId}/federated-credentials/{credentialId}',
operationId: 'updateFederatedCredential',
summary: 'Update application federated credential',
request: { params: federatedCredentialParam, body: jsonBody(updateManagementFederatedCredentialRequestSchema) },
response: createManagementFederatedCredentialResponseSchema,
},
{
method: 'delete',
path: '/applications/{applicationId}/federated-credentials/{credentialId}',
operationId: 'deleteFederatedCredential',
summary: 'Delete application federated credential',
request: { params: federatedCredentialParam },
noBody: true,
},
{
method: 'get',
path: '/resource-servers',
operationId: 'listResourceServers',
summary: 'List Resource Servers',
security: [{ oauth2: ['resource-servers:read'] }, { sessionCookie: ['resource-servers:read'] }],
request: { query: listApiResourcesQuerySchema },
response: resourceServersResponseSchema,
paginated: true,
},
{
method: 'post',
path: '/resource-servers',
operationId: 'createResourceServer',
summary: 'Create a Resource Server',
request: { body: jsonBody(createApiResourceSchema) },
response: resourceServerSchema,
status: 201,
responseHeaders: locationResponseHeader,
errors: { 409: 'An active Resource Server already uses the identifier or resource URL.' },
},
{
method: 'get',
path: '/resource-servers/{resourceServerId}',
operationId: 'getResourceServer',
summary: 'Get a Resource Server',
security: [{ oauth2: ['resource-servers:read'] }, { sessionCookie: ['resource-servers:read'] }],
request: { params: resourceServerIdParam },
response: resourceServerSchema,
},
{
method: 'get',
path: '/resource-servers/{resourceServerId}/contract',
operationId: 'getResourceServerContract',
summary: 'Get a Resource Server contract',
request: { params: resourceServerIdParam },
response: apiResourceContractResponseSchema,
errors: {
404: 'The API resource was not found.',
502: 'The Resource Server contract could not be retrieved or validated.',
},
},
{
method: 'put',
path: '/resource-servers/{resourceServerId}/scope-registry',
operationId: 'replaceResourceServerScopeRegistry',
summary: 'Synchronize a Resource Server scope registry',
request: { params: resourceServerIdParam },
response: resourceServerSchema,
noBody: true,
errors: {
400: 'The Resource Server is inactive or system-managed.',
502: 'The Resource Server scope registry could not be synchronized.',
},
},
{
method: 'patch',
path: '/resource-servers/{resourceServerId}',
operationId: 'updateResourceServer',
summary: 'Update a Resource Server',
request: { params: resourceServerIdParam, body: jsonBody(updateApiResourceSchema) },
response: resourceServerSchema,
errors: { 409: 'An active Resource Server already uses the identifier or resource URL.' },
},
{
method: 'delete',
path: '/resource-servers/{resourceServerId}',
operationId: 'deleteResourceServer',
summary: 'Delete a Resource Server',
request: { params: resourceServerIdParam },
noBody: true,
errors: { 404: 'The Resource Server was already deleted or does not exist.' },
},
{
method: 'get',
path: '/users/{userId}/authorized-resource-servers',
operationId: 'listUserAuthorizedResourceServers',
summary: 'List Resource Servers authorized for a User',
security: [{ oauth2: ['permissions:read'] }, { sessionCookie: ['permissions:read'] }],
request: { params: z.object({ userId: z.string() }), query: listAuthorizedResourceServersQuerySchema },
response: listAuthorizedResourceServersResponseSchema,
paginated: true,
errors: { 400: 'The collection query is invalid.', 404: 'The User was not found.' },
},
{
method: 'get',
path: '/users/{userId}/permissions',
operationId: 'listUserPermissions',
summary: 'List a User’s direct Permissions',
security: [{ oauth2: ['permissions:read'] }, { sessionCookie: ['permissions:read'] }],
request: { params: z.object({ userId: z.string() }), query: listPermissionsQuerySchema },
response: listUserPermissionsResponseSchema,
paginated: true,
errors: { 400: 'The collection query is invalid.' },
},
{
method: 'post',
path: '/users/{userId}/permissions',
operationId: 'createUserPermission',
summary: 'Create a direct User Permission',
security: [{ oauth2: ['permissions:write'] }, { sessionCookie: ['permissions:write'] }],
request: { params: z.object({ userId: z.string() }), body: jsonBody(createUserPermissionRequestSchema) },
response: permissionResponseSchema,
status: 201,
responseHeaders: locationResponseHeader,
errors: { 400: 'The request body is invalid.', 404: 'The User or Resource Server was not found.' },
},
{
method: 'get',
path: '/users/{userId}/permissions/{permissionId}',
operationId: 'getUserPermission',
summary: 'Get a direct User Permission',
security: [{ oauth2: ['permissions:read'] }, { sessionCookie: ['permissions:read'] }],
request: { params: z.object({ userId: z.string(), permissionId: z.string() }) },
response: permissionResponseSchema,
errors: { 404: 'The User Permission was not found.' },
},
{
method: 'delete',
path: '/users/{userId}/permissions/{permissionId}',
operationId: 'deleteUserPermission',
summary: 'Revoke a direct User Permission',
security: [{ oauth2: ['permissions:write'] }, { sessionCookie: ['permissions:write'] }],
request: { params: z.object({ userId: z.string(), permissionId: z.string() }) },
noBody: true,
errors: { 404: 'The User Permission was not found.' },
},
{
method: 'get',
path: '/applications/{applicationId}/authorized-resource-servers',
operationId: 'listApplicationAuthorizedResourceServers',
summary: 'List Resource Servers authorized for an Application',
security: [{ oauth2: ['permissions:read'] }, { sessionCookie: ['permissions:read'] }],
request: {
params: z.object({ applicationId: z.string() }),
query: listAuthorizedResourceServersQuerySchema,
},
response: listAuthorizedResourceServersResponseSchema,
paginated: true,
errors: { 400: 'The collection query is invalid.', 404: 'The Application was not found.' },
},
{
method: 'get',
path: '/applications/{applicationId}/permissions',
operationId: 'listApplicationPermissions',
summary: 'List an Application’s direct Permissions',
security: [{ oauth2: ['permissions:read'] }, { sessionCookie: ['permissions:read'] }],
request: { params: z.object({ applicationId: z.string() }), query: listPermissionsQuerySchema },
response: listApplicationPermissionsResponseSchema,
paginated: true,
errors: { 400: 'The collection query is invalid.', 404: 'The Application was not found.' },
},
{
method: 'post',
path: '/applications/{applicationId}/permissions',
operationId: 'createApplicationPermission',
summary: 'Create a direct Application Permission',
security: [{ oauth2: ['permissions:write'] }, { sessionCookie: ['permissions:write'] }],
request: {
params: z.object({ applicationId: z.string() }),
body: jsonBody(createApplicationPermissionRequestSchema),
},
response: permissionResponseSchema,
status: 201,
responseHeaders: locationResponseHeader,
errors: { 400: 'The request body is invalid.', 404: 'The Application or Resource Server was not found.' },
},
{
method: 'get',
path: '/applications/{applicationId}/permissions/{permissionId}',
operationId: 'getApplicationPermission',
summary: 'Get a direct Application Permission',
security: [{ oauth2: ['permissions:read'] }, { sessionCookie: ['permissions:read'] }],
request: { params: z.object({ applicationId: z.string(), permissionId: z.string() }) },
response: permissionResponseSchema,
errors: { 404: 'The Application Permission was not found.' },
},
{
method: 'delete',
path: '/applications/{applicationId}/permissions/{permissionId}',
operationId: 'deleteApplicationPermission',
summary: 'Revoke a direct Application Permission',
security: [{ oauth2: ['permissions:write'] }, { sessionCookie: ['permissions:write'] }],
request: { params: z.object({ applicationId: z.string(), permissionId: z.string() }) },
noBody: true,
errors: { 404: 'The Application Permission was not found.' },
},
{
method: 'get',
path: '/organizations',
operationId: 'listOrganizations',
summary: 'List organizations',
request: { query: paginationQuerySchema },
response: listOrganizationsResponseSchema,
paginated: true,
},
{
method: 'post',
path: '/organizations',
operationId: 'createOrganization',
summary: 'Create organization',
request: { body: jsonBody(createOrganizationRequestSchema) },
response: organizationResponseSchema,
status: 201,
responseHeaders: locationResponseHeader,
},
{
method: 'get',
path: '/organizations/{organizationId}',
operationId: 'getOrganization',
summary: 'Get organization',
request: { params: organizationIdParam },
response: organizationResponseSchema,
},
{
method: 'patch',
path: '/organizations/{organizationId}',
operationId: 'updateOrganization',
summary: 'Update organization',
request: { params: organizationIdParam, body: jsonBody(updateOrganizationRequestSchema) },
response: organizationResponseSchema,
},
{
method: 'delete',
path: '/organizations/{organizationId}',
operationId: 'deleteOrganization',
summary: 'Delete organization',
request: { params: organizationIdParam },
noBody: true,
},
{
method: 'get',
path: '/organizations/{organizationId}/members',
operationId: 'listOrganizationMembers',
summary: 'List organization members',
request: { params: organizationIdParam, query: paginationQuerySchema },
response: listMembersResponseSchema,
paginated: true,
},
{
method: 'post',
path: '/organizations/{organizationId}/members',
operationId: 'createOrganizationMember',
summary: 'Create organization member',
request: { params: organizationIdParam, body: jsonBody(addMemberRequestSchema) },
response: memberResponseSchema,
status: 201,
responseHeaders: locationResponseHeader,
},
{
method: 'get',
path: '/organizations/{organizationId}/members/{memberId}',
operationId: 'getOrganizationMember',
summary: 'Get organization member',
request: { params: memberParam },
response: memberResponseSchema,
},
{
method: 'patch',
path: '/organizations/{organizationId}/members/{memberId}',
operationId: 'updateOrganizationMember',
summary: 'Update organization member',
request: { params: memberParam, body: jsonBody(updateMemberRequestSchema) },
response: z.object({ member: z.unknown() }),
},
{
method: 'delete',
path: '/organizations/{organizationId}/members/{memberId}',
operationId: 'deleteOrganizationMember',
summary: 'Delete organization member',
request: { params: memberParam },
noBody: true,
},
{
method: 'get',
path: '/organizations/{organizationId}/invitations',
operationId: 'listOrganizationInvitations',
summary: 'List organization invitations',
request: { params: organizationIdParam, query: paginationQuerySchema },
response: listInvitationsResponseSchema,
paginated: true,
},
{
method: 'post',
path: '/organizations/{organizationId}/invitations',
operationId: 'createOrganizationInvitation',
summary: 'Create organization invitation',
request: { params: organizationIdParam, body: jsonBody(createInvitationRequestSchema) },
response: invitationResponseSchema,
status: 201,
responseHeaders: locationResponseHeader,
},
{
method: 'get',
path: '/organizations/{organizationId}/invitations/{invitationId}',
operationId: 'getOrganizationInvitation',
summary: 'Get organization invitation',
request: { params: invitationParam },
response: invitationResponseSchema,
},
{
method: 'delete',
path: '/organizations/{organizationId}/invitations/{invitationId}',
operationId: 'deleteOrganizationInvitation',
summary: 'Delete organization invitation',
request: { params: invitationParam },
noBody: true,
},
{
method: 'get',
path: '/organizations/{organizationId}/roles',
operationId: 'listOrganizationRoles',
summary: 'List Organization Roles',
request: { params: organizationIdParam, query: paginationQuerySchema },
response: listRolesResponseSchema,
paginated: true,
},
{
method: 'post',
path: '/organizations/{organizationId}/roles',
operationId: 'createOrganizationRole',
summary: 'Create an Organization Role',
request: { params: organizationIdParam, body: jsonBody(createRoleRequestSchema) },
response: roleResponseSchema,
status: 201,
responseHeaders: locationResponseHeader,
},
{
method: 'get',
path: '/organizations/{organizationId}/roles/{roleKey}',
operationId: 'getOrganizationRole',
summary: 'Get an Organization Role',
request: { params: organizationIdParam.merge(roleKeyParam) },
response: roleResponseSchema,
},
{
method: 'patch',
path: '/organizations/{organizationId}/roles/{roleKey}',
operationId: 'updateOrganizationRole',
summary: 'Update an Organization Role',
request: { params: organizationIdParam.merge(roleKeyParam), body: jsonBody(updateRoleRequestSchema) },
response: roleResponseSchema,
},
{
method: 'delete',
path: '/organizations/{organizationId}/roles/{roleKey}',
operationId: 'deleteOrganizationRole',
summary: 'Delete an Organization Role',
request: { params: organizationIdParam.merge(roleKeyParam) },
noBody: true,
},
{
method: 'get',
path: '/organizations/{organizationId}/members/{memberId}/roles',
operationId: 'getOrganizationMemberRoles',
summary: 'Get Organization member Roles',
request: { params: memberParam },
response: memberRolesResponseSchema,
},
{
method: 'put',
path: '/organizations/{organizationId}/members/{memberId}/roles',
operationId: 'replaceOrganizationMemberRoles',
summary: 'Replace Organization member Roles',
request: { params: memberParam, body: jsonBody(replaceMemberRolesRequestSchema) },
response: memberRolesResponseSchema,
},
]