# Applications O módulo `azion/applications` é a biblioteca da Azion Lib para [Applications](/pt-br/documentacao/plataforma/applications/). Suas funções criam, listam, leem, atualizam e excluem applications. Dentro de uma application, elas gerenciam as [origens](/pt-br/documentacao/plataforma/connectors/origins/), os [cache settings](/pt-br/documentacao/plataforma/applications/cache/cache-settings/), os [device groups](/pt-br/documentacao/plataforma/applications/device-groups/), as [instâncias de function](/pt-br/documentacao/plataforma/applications/functions-instances/) e as [regras](/pt-br/documentacao/plataforma/applications/rules-engine/) dela. O módulo chama a Azion API v3, e cada função recebe um único objeto como argumento. Instale o pacote: ```bash npm install azion ``` O pacote `azion` recebe apenas correções de bugs, e a manutenção dele termina em dezembro de 2026. Os exemplos desta página são módulos ES que usam `await` de nível superior e rodam no Node.js. A maioria deles é em TypeScript. Um exemplo cujo payload o TypeScript rejeita é em JavaScript, e a seção dele nomeia o tipo que o rejeita. --- ## Autenticação As funções que você importa e chama diretamente leem o seu [personal token](/pt-br/documentacao/fundamentos/personal-tokens/) da variável de ambiente `AZION_TOKEN`. Um client criado com [createAzionApplicationClient](#createazionapplicationclient) carrega o token no campo `token` dele. | Variável | Descrição | | ------------- | ---------------------------------- | | `AZION_TOKEN` | O seu personal token da Azion. | | `AZION_DEBUG` | Com `true`, ativa o modo de debug. | Para mais informações, consulte [Como a Azion Lib funciona](/pt-br/documentacao/devtools/azion-lib/como-funciona/). --- ## Envelope de resposta As funções de `azion/applications` informam uma falha de uma de duas formas, conforme o objeto sobre o qual agem: - As funções de nível de application [createApplication](#createapplication), [getApplications](#getapplications), [getApplication](#getapplication), [patchApplication](#patchapplication) e [putApplication](#putapplication) retornam `{ data }` em caso de sucesso. Quando a API responde com um status de erro, elas lançam `Error: HTTP error! Status: - `, então chame-as dentro de `try`/`catch`. - [deleteApplication](#deleteapplication) e as funções de origens, cache settings, device groups, instâncias de function e regras não lançam erros. Elas retornam um [AzionApplicationResponse](#azionapplicationresponse), `{ data?, error? }`. Em caso de falha, `error` contém `{ message, operation }`, em que `operation` nomeia a chamada, como `get origin`. Os exemplos das funções de nível de application também desestruturam `error`. Em uma requisição com falha, essas funções lançam o erro antes que o exemplo o verifique. Uma exclusão bem-sucedida ainda retorna `{ error: { message: 'Expected JSON response, but got: ', operation } }`. A API responde a uma exclusão com um corpo vazio, que o módulo lê como um erro. O envelope não distingue uma exclusão bem-sucedida de uma que falhou, por isso cada exemplo de exclusão desta página lê o objeto de volta. Uma resposta `404` confirma a exclusão. --- ## Funções por recurso O módulo agrupa as funções pelo objeto que elas gerenciam. Uma application é identificada por `applicationId`, que toda função recebe, exceto `createApplication` e `getApplications`. As regras também recebem uma `phase`, e uma origem é identificada pela `originKey` dela, um UUID. | Recurso | Funções | | --------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Application | [createApplication](#createapplication), [getApplications](#getapplications), [getApplication](#getapplication), [patchApplication](#patchapplication), [putApplication](#putapplication), [deleteApplication](#deleteapplication) | | Origem | [createOrigin](#createorigin), [getOrigins](#getorigins), [getOrigin](#getorigin), [updateOrigin](#updateorigin), [deleteOrigin](#deleteorigin) | | Cache setting | [createCacheSetting](#createcachesetting), [getCacheSettings](#getcachesettings), [getCacheSetting](#getcachesetting), [updateCacheSetting](#updatecachesetting), [deleteCacheSetting](#deletecachesetting) | | Device group | [createDeviceGroup](#createdevicegroup), [getDeviceGroups](#getdevicegroups), [getDeviceGroup](#getdevicegroup), [updateDeviceGroup](#updatedevicegroup), [deleteDeviceGroup](#deletedevicegroup) | | Instância de function | [createFunctionInstance](#createfunctioninstance), [getFunctionInstances](#getfunctioninstances), [getFunctionInstance](#getfunctioninstance), [updateFunctionInstance](#updatefunctioninstance), [deleteFunctionInstance](#deletefunctioninstance) | | Regra | [createRule](#createrule), [getRules](#getrules), [getRule](#getrule), [updateRule](#updaterule), [deleteRule](#deleterule) | Uma application que [createApplication](#createapplication) ou [getApplication](#getapplication) retorna também carrega as funções dos cinco sub-recursos como [métodos da application](#metodos-da-application). --- ## createAzionApplicationClient Cria um client que guarda um token e expõe as seis funções de nível de application como métodos. `createAzionApplicationClient` também é o export padrão do módulo. Em TypeScript com `moduleResolution` definido como `nodenext`, o import padrão não pode ser chamado, então importe o export nomeado. Com `moduleResolution` definido como `bundler`, os dois imports passam na verificação de tipos. ```typescript function createAzionApplicationClient(config?: Partial<{ token: string; options?: AzionClientOptions; }>): AzionApplicationsClient; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | --------- | ------------------------------------------- | ----------- | --------------------------------------------------------------------- | | `token` | `string` | Não | O seu personal token da Azion. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. Nenhum exemplo desta página as passa ao client. | Retorna um [AzionApplicationsClient](#azionapplicationsclient). Os métodos dele recebem o mesmo objeto que a função correspondente desta página. O client não tem métodos para origens, cache settings, device groups, instâncias de function ou regras: chame essas funções diretamente ou use os [métodos da application](#metodos-da-application). Este exemplo cria um client e imprime os métodos dele: ```typescript import { createAzionApplicationClient } from 'azion/applications'; const client = createAzionApplicationClient({ token: process.env.AZION_TOKEN, }); console.log('client methods:', Object.keys(client)); ``` Saída: ```text client methods: [ 'createApplication', 'deleteApplication', 'getApplication', 'getApplications', 'putApplication', 'patchApplication' ] ``` --- ## createApplication Cria uma application. ```typescript function createApplication(params: { data: ApiCreateApplicationPayload; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | --------- | --------------------------------------------------------- | ----------- | ------------------------------------------------------ | | `data` | [`ApiBaseApplicationPayload`](#apibaseapplicationpayload) | Sim | As configurações da application. `name` é obrigatório. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Retorna `data` como a [AzionApplication](#azionapplication) criada, com o `id` que a API atribuiu. Em caso de status de erro, a função lança um erro. O tipo declara `application_acceleration`, mas a API v3 o recusa em uma requisição de criação como um campo desconhecido. Com ele, a função lança `Error: HTTP error! Status: 400 - BAD REQUEST`, então deixe-o de fora. Este exemplo é em JavaScript, porque o TypeScript rejeita a string `'http,https'` para `delivery_protocol`, cujo tipo é o enum `DeliveryProtocol`: ```javascript import { createApplication } from 'azion/applications'; // Create a new application const { data: newApp, error } = await createApplication({ data: { name: 'my-app', delivery_protocol: 'http,https', }, }); if (newApp) { console.log(`Application created: ${newApp.id} (${newApp.name}, ${newApp.delivery_protocol})`); } else { console.error('Error creating application:', error); } ``` Saída: ```text Application created: 1234567890 (my-app, http,https) ``` --- ## getApplications Lista as applications da conta, uma página por vez. ```typescript function getApplications(params?: { params?: ApiListApplicationsParams; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | --------- | --------------------------------------------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------- | | `params` | [`ApiListApplicationsParams`](#apilistapplicationsparams) | Não | Paginação: `page` e `page_size`. Sem chaves de ordenação, a função pede a lista ordenada por nome, em ordem crescente. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Retorna um [AzionApplicationCollectionResponse](#azionapplicationcollectionresponse): `data.results` contém a página, e `data.count` contém o número de applications da conta. Em caso de status de erro, a função lança um erro. ```typescript import { getApplications } from 'azion/applications'; // List all applications const { data: apps, error } = await getApplications({ params: { page: 1, page_size: 20 }, }); if (apps) { console.log(`Found ${apps.count} applications; this page has ${apps.results.length}`); } else { console.error('Error listing applications:', error); } ``` Saída: ```text Found 22 applications; this page has 20 ``` --- ## getApplication Retorna uma application pelo ID dela. ```typescript function getApplication(params: { applicationId: number; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | --------------- | ------------------------------------------- | ----------- | --------------------- | | `applicationId` | `number` | Sim | O ID da application. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Retorna `data` como uma [AzionApplication](#azionapplication) que carrega os [métodos da application](#metodos-da-application). Um ID que não corresponde a nenhuma application faz a função lançar `Error: HTTP error! Status: 404 - NOT FOUND`. ```typescript import { getApplication } from 'azion/applications'; // Retrieve a specific application const applicationId = 1234567890; // Replace with the actual application ID const { data: app, error } = await getApplication({ applicationId }); if (error) { console.error('Error retrieving application:', error); } else { console.log('Application details:', app?.id, app?.name, app?.delivery_protocol, app?.active); } ``` Saída: ```text Application details: 1234567890 my-app http,https true ``` --- ## patchApplication Envia em uma requisição `PATCH` os campos da application que você passa. Use-a para renomear uma application ou para mudar uma configuração, como `edge_functions: true`, que [createFunctionInstance](#createfunctioninstance) exige. ```typescript function patchApplication(params: { applicationId: number; data: Partial; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | --------------- | ----------------------------------------------------------- | ----------- | ----------------------------------------- | | `applicationId` | `number` | Sim | O ID da application a atualizar. | | `data` | [`ApiUpdateApplicationPayload`](#apibaseapplicationpayload) | Sim | Os campos a mudar. Todo campo é opcional. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Retorna `data` como a [AzionApplication](#azionapplication) atualizada. Em caso de status de erro, a função lança um erro. ```typescript import { patchApplication } from 'azion/applications'; // Update some fields of an existing application const applicationId = 1234567890; // Replace with the actual application ID const { data: updatedApp, error } = await patchApplication({ applicationId, data: { name: 'my-app-patched' }, }); if (error) { console.error('Error updating application:', error); } else { console.log('Updated application:', updatedApp?.id, updatedApp?.name); } ``` Saída: ```text Updated application: 1234567890 my-app-patched ``` --- ## putApplication Envia em uma requisição `PUT` as configurações da application que você passa. ```typescript function putApplication(params: { applicationId: number; data: ApiUpdateApplicationPayload; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | --------------- | ----------------------------------------------------------- | ----------- | -------------------------------- | | `applicationId` | `number` | Sim | O ID da application a atualizar. | | `data` | [`ApiUpdateApplicationPayload`](#apibaseapplicationpayload) | Sim | As configurações da application. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Retorna `data` como a [AzionApplication](#azionapplication) atualizada. Em caso de status de erro, a função lança um erro. A API v3 pode recusar um valor de `delivery_protocol` que o tipo permite. Por exemplo, a API pode responder a `delivery_protocol: 'https'` com `"https" is not a valid choice.`, e a função então lança um erro. Este exemplo é em JavaScript, porque o TypeScript rejeita a string `'http'` para `delivery_protocol`, cujo tipo é o enum `DeliveryProtocol`: ```javascript import { putApplication } from 'azion/applications'; // Replace the settings of an existing application const applicationId = 1234567890; // Replace with the actual application ID const { data: updatedApp, error } = await putApplication({ applicationId, data: { name: 'my-app', delivery_protocol: 'http', }, }); if (error) { console.error('Error updating application:', error); } else { console.log('Updated application:', updatedApp.id, updatedApp.name, updatedApp.delivery_protocol); } ``` Saída: ```text Updated application: 1234567890 my-app http ``` --- ## deleteApplication Exclui uma application pelo ID dela. ```typescript function deleteApplication(params: { applicationId: number; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | --------------- | ------------------------------------------- | ----------- | ------------------------------ | | `applicationId` | `number` | Sim | O ID da application a excluir. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Ao contrário das outras funções de nível de application, `deleteApplication` retorna um envelope e não lança erros. Uma exclusão bem-sucedida retorna `error` com a mensagem `Expected JSON response, but got: `, por isso o exemplo confirma a exclusão com [getApplication](#getapplication), que lança um erro 404 para uma application que não existe mais. ```typescript import { deleteApplication, getApplication } from 'azion/applications'; // Delete an existing application const applicationId = 1234567890; // Replace with the actual application ID const { error: deleteError } = await deleteApplication({ applicationId }); // On success (HTTP 204) the envelope still carries an error, so confirm by reading it back; // getApplication throws when the application does not exist try { await getApplication({ applicationId }); console.error('Error deleting application:', deleteError); } catch (err) { console.log(`Application ${applicationId} deleted (read back: ${(err as Error).message})`); } ``` Saída: ```text Application 1234567890 deleted (read back: HTTP error! Status: 404 - NOT FOUND) ``` --- ## createOrigin Cria uma origem em uma application. Uma origem é o servidor do qual a application obtém o conteúdo. ```typescript function createOrigin(params: { applicationId: number; data: ApiCreateOriginPayload; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | --------------- | ------------------------------------------- | ----------- | ------------------------------------------------------------------------------------------------ | | `applicationId` | `number` | Sim | O ID da application. | | `data` | [`ApiCreateOriginPayload`](#azionorigin) | Sim | As configurações da origem. O exemplo define `name`, `origin_type`, `addresses` e `host_header`. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Retorna `data` como a [AzionOrigin](#azionorigin) criada. A API identifica uma origem pela `origin_key` dela, um UUID, que as outras funções de origem recebem como `originKey`. Este exemplo é em JavaScript, porque `ApiCreateOriginPayload` exige todos os campos da origem, incluindo `origin_key` e os campos de HMAC, e tipa `origin_type` como um enum: ```javascript import { createOrigin } from 'azion/applications'; const applicationId = 1234567890; // Replace with the actual application ID // Define the data for the new origin const newOriginData = { name: 'my-origin', origin_type: 'single_origin', addresses: [{ address: 'example.com' }], host_header: '${host}', }; // Create a new origin const { data: newOrigin, error } = await createOrigin({ applicationId, data: newOriginData }); if (error) { console.error('Error creating origin:', error); } else { console.log('Created origin:', newOrigin.origin_key, newOrigin.name, newOrigin.addresses); } ``` Saída: ```text Created origin: 11111111-1111-1111-1111-111111111111 my-origin [ { address: 'example.com', weight: null, server_role: 'primary', is_active: true } ] ``` --- ## getOrigins Lista as origens de uma application, uma página por vez. ```typescript function getOrigins(params: { applicationId: number; params?: ApiListOriginsParams; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | --------------- | ---------------------------------------------- | ----------- | -------------------------------- | | `applicationId` | `number` | Sim | O ID da application. | | `params` | [`ApiListOriginsParams`](#parametros-de-lista) | Não | Paginação: `page` e `page_size`. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Retorna um [AzionApplicationCollectionResponse](#azionapplicationcollectionresponse) cujo `data.results` contém objetos [AzionOrigin](#azionorigin). ```typescript import { getOrigins } from 'azion/applications'; const applicationId = 1234567890; // Replace with the actual application ID const { data: origins, error } = await getOrigins({ applicationId, params: { page: 1, page_size: 10 } }); if (error) { console.error('Error listing origins:', error); } else { console.log(`Found ${origins?.count} origins:`, origins?.results.map((o) => `${o.name} (${o.origin_key})`)); } ``` Saída: ```text Found 1 origins: [ 'my-origin (11111111-1111-1111-1111-111111111111)' ] ``` --- ## getOrigin Retorna uma origem de uma application pela chave de origem dela. ```typescript function getOrigin(params: { applicationId: number; originKey: string; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | --------------- | ------------------------------------------- | ----------- | ---------------------------------- | | `applicationId` | `number` | Sim | O ID da application. | | `originKey` | `string` | Sim | A `origin_key` da origem, um UUID. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Retorna `data` como uma [AzionOrigin](#azionorigin). Uma chave que não corresponde a nenhuma origem retorna `error` com a mensagem `HTTP error! Status: 404 - NOT FOUND` e a operação `get origin`. ```typescript import { getOrigin } from 'azion/applications'; const applicationId = 1234567890; // Replace with the actual application ID const originKey = '11111111-1111-1111-1111-111111111111'; // Replace with the origin key (a UUID) const { data: origin, error } = await getOrigin({ applicationId, originKey }); if (error) { console.error('Error retrieving origin:', error); } else { console.log('Origin details:', origin?.origin_key, origin?.name, origin?.origin_type, origin?.host_header); } ``` Saída: ```text Origin details: 11111111-1111-1111-1111-111111111111 my-origin single_origin ${host} ``` --- ## updateOrigin Envia em uma requisição `PATCH` os campos da origem que você passa. ```typescript function updateOrigin(params: { applicationId: number; originKey: string; data: ApiUpdateOriginRequest; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | --------------- | ------------------------------------------- | ----------- | ------------------------------------- | | `applicationId` | `number` | Sim | O ID da application. | | `originKey` | `string` | Sim | A `origin_key` da origem a atualizar. | | `data` | [`ApiUpdateOriginRequest`](#azionorigin) | Sim | Os campos a mudar. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Retorna `data` como a [AzionOrigin](#azionorigin) atualizada. Este exemplo é em JavaScript, porque `ApiUpdateOriginRequest` exige um `id`, de que a requisição não precisa: ```javascript import { updateOrigin } from 'azion/applications'; const applicationId = 1234567890; // Replace with the actual application ID const originKey = '11111111-1111-1111-1111-111111111111'; // Replace with the origin key (a UUID) const { data: updatedOrigin, error } = await updateOrigin({ applicationId, originKey, data: { name: 'my-origin-updated' }, }); if (error) { console.error('Error updating origin:', error); } else { console.log('Updated origin:', updatedOrigin.origin_key, updatedOrigin.name); } ``` Saída: ```text Updated origin: 11111111-1111-1111-1111-111111111111 my-origin-updated ``` --- ## deleteOrigin Exclui uma origem de uma application pela chave de origem dela. ```typescript function deleteOrigin(params: { applicationId: number; originKey: string; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | --------------- | ------------------------------------------- | ----------- | ----------------------------------- | | `applicationId` | `number` | Sim | O ID da application. | | `originKey` | `string` | Sim | A `origin_key` da origem a excluir. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Uma exclusão bem-sucedida retorna `error` com a mensagem `Expected JSON response, but got: `, por isso o exemplo lê a origem de volta com [getOrigin](#getorigin). Um erro `404` confirma a exclusão. ```typescript import { deleteOrigin, getOrigin } from 'azion/applications'; const applicationId = 1234567890; // Replace with the actual application ID const originKey = '11111111-1111-1111-1111-111111111111'; // Replace with the origin key (a UUID) const { error: deleteError } = await deleteOrigin({ applicationId, originKey }); // On success (HTTP 204) the envelope still carries an error, so confirm by reading the origin back const { error } = await getOrigin({ applicationId, originKey }); if (error) { console.log(`Origin ${originKey} deleted (read back: ${error.message})`); } else { console.error('Error deleting origin:', deleteError); } ``` Saída: ```text Origin 11111111-1111-1111-1111-111111111111 deleted (read back: HTTP error! Status: 404 - NOT FOUND) ``` --- ## createCacheSetting Cria um cache setting em uma application. A application precisa ter uma origem antes. Em uma application sem nenhuma, a API recusa o cache setting, e a função retorna `error` com a mensagem `HTTP error! Status: 400 - BAD REQUEST`. ```typescript function createCacheSetting(params: { applicationId: number; data: ApiBaseCacheSettingPayload; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | --------------- | ----------------------------------------------------------- | ----------- | -------------------------------------------------------- | | `applicationId` | `number` | Sim | O ID da application. | | `data` | [`ApiBaseCacheSettingPayload`](#apibasecachesettingpayload) | Sim | As configurações do cache setting. `name` é obrigatório. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | `browser_cache_settings` recebe `honor`, `override` ou `ignore`, e `cdn_cache_settings` recebe `honor` ou `override`. Com `override`, o exemplo também define o campo de TTL máximo correspondente, `browser_cache_settings_maximum_ttl` ou `cdn_cache_settings_maximum_ttl`. Retorna `data` como o [AzionCacheSetting](#azioncachesetting) criado, com o `id` dele. Este exemplo é em JavaScript, porque o TypeScript rejeita valores de string para `browser_cache_settings` e `cdn_cache_settings`, cujos tipos são enums que o módulo não exporta: ```javascript import { createCacheSetting } from 'azion/applications'; const applicationId = 1234567890; // Replace with the actual application ID // Create a new cache setting const cacheSettingData = { name: 'my-cache-setting', browser_cache_settings: 'override', browser_cache_settings_maximum_ttl: 3600, cdn_cache_settings: 'override', cdn_cache_settings_maximum_ttl: 7200, }; const { data: newCacheSetting, error } = await createCacheSetting({ applicationId, data: cacheSettingData }); if (error) { console.error('Error creating cache setting:', error); } else { console.log('Cache setting created successfully:', newCacheSetting.id, newCacheSetting.name, newCacheSetting.cdn_cache_settings_maximum_ttl); } ``` Saída: ```text Cache setting created successfully: 234567 my-cache-setting 7200 ``` --- ## getCacheSettings Lista os cache settings de uma application, uma página por vez. ```typescript function getCacheSettings(params: { applicationId: number; params?: ApiListCacheSettingsParams; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | --------------- | ---------------------------------------------------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------------- | | `applicationId` | `number` | Sim | O ID da application. | | `params` | [`ApiListCacheSettingsParams`](#parametros-de-lista) | Não | Paginação: `page` e `page_size`. Deixe de fora `sort` e `order`: a API recusa os valores que o tipo declara para eles com um erro 400. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Retorna um [AzionApplicationCollectionResponse](#azionapplicationcollectionresponse) cujo `data.results` contém objetos [AzionCacheSetting](#azioncachesetting). ```typescript import { getCacheSettings } from 'azion/applications'; const applicationId = 1234567890; // Replace with the actual application ID const { data: cacheSettings, error } = await getCacheSettings({ applicationId, params: { page: 1, page_size: 20 }, }); if (error) { console.error('Error listing cache settings:', error); } else { console.log(`Found ${cacheSettings?.count} cache settings:`, cacheSettings?.results.map((c) => `${c.id} ${c.name}`)); } ``` Saída: ```text Found 1 cache settings: [ '234568 my-other-cache-setting' ] ``` --- ## getCacheSetting Retorna um cache setting de uma application pelo ID dele. ```typescript function getCacheSetting(params: { applicationId: number; cacheSettingId: number; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | ---------------- | ------------------------------------------- | ----------- | ---------------------- | | `applicationId` | `number` | Sim | O ID da application. | | `cacheSettingId` | `number` | Sim | O ID do cache setting. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Retorna `data` como um [AzionCacheSetting](#azioncachesetting). ```typescript import { getCacheSetting } from 'azion/applications'; const applicationId = 1234567890; // Replace with the actual application ID const cacheSettingId = 234567; // Replace with the actual cache setting ID const { data: cacheSetting, error } = await getCacheSetting({ applicationId, cacheSettingId }); if (error) { console.error('Error retrieving cache setting:', error); } else { console.log('Cache setting details:', cacheSetting?.id, cacheSetting?.name, cacheSetting?.browser_cache_settings, cacheSetting?.cdn_cache_settings); } ``` Saída: ```text Cache setting details: 234567 my-cache-setting override override ``` --- ## updateCacheSetting Envia em uma requisição `PATCH` os campos do cache setting que você passa. ```typescript function updateCacheSetting(params: { applicationId: number; cacheSettingId: number; data: ApiUpdateCacheSettingPayload; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | ---------------- | ------------------------------------------------------------- | ----------- | ----------------------------------------- | | `applicationId` | `number` | Sim | O ID da application. | | `cacheSettingId` | `number` | Sim | O ID do cache setting a atualizar. | | `data` | [`ApiUpdateCacheSettingPayload`](#apibasecachesettingpayload) | Sim | Os campos a mudar. Todo campo é opcional. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Retorna `data` como o [AzionCacheSetting](#azioncachesetting) atualizado. Um payload sem campos de enum, como `name` e um TTL, passa na verificação de tipos do TypeScript. ```typescript import { updateCacheSetting } from 'azion/applications'; const applicationId = 1234567890; // Replace with the actual application ID const cacheSettingId = 234567; // Replace with the actual cache setting ID const { data: updatedCacheSetting, error } = await updateCacheSetting({ applicationId, cacheSettingId, data: { name: 'my-cache-setting-updated', cdn_cache_settings_maximum_ttl: 3600 }, }); if (error) { console.error('Error updating cache setting:', error); } else { console.log('Cache setting updated:', updatedCacheSetting?.name, updatedCacheSetting?.cdn_cache_settings_maximum_ttl); } ``` Saída: ```text Cache setting updated: my-cache-setting-updated 3600 ``` --- ## deleteCacheSetting Exclui um cache setting de uma application pelo ID dele. ```typescript function deleteCacheSetting(params: { applicationId: number; cacheSettingId: number; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | ---------------- | ------------------------------------------- | ----------- | -------------------------------- | | `applicationId` | `number` | Sim | O ID da application. | | `cacheSettingId` | `number` | Sim | O ID do cache setting a excluir. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Uma exclusão bem-sucedida retorna `error` com a mensagem `Expected JSON response, but got: `, por isso o exemplo lê o cache setting de volta com [getCacheSetting](#getcachesetting). Um erro `404` confirma a exclusão. ```typescript import { deleteCacheSetting, getCacheSetting } from 'azion/applications'; const applicationId = 1234567890; // Replace with the actual application ID const cacheSettingId = 234567; // Replace with the actual cache setting ID const { error: deleteError } = await deleteCacheSetting({ applicationId, cacheSettingId }); // On success (HTTP 204) the envelope still carries an error, so confirm by reading it back const { error } = await getCacheSetting({ applicationId, cacheSettingId }); if (error) { console.log(`Cache setting ${cacheSettingId} deleted (read back: ${error.message})`); } else { console.error('Error deleting cache setting:', deleteError); } ``` Saída: ```text Cache setting 234567 deleted (read back: HTTP error! Status: 404 - NOT FOUND) ``` --- ## createDeviceGroup Cria um device group em uma application. Um device group identifica dispositivos por uma expressão regular que a plataforma compara com o header de requisição `User-Agent`. ```typescript function createDeviceGroup(params: { applicationId: number; data: ApiCreateDeviceGroupPayload; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | --------------- | ------------------------------------------- | ----------- | --------------------------------------------------------------------------------------------------- | | `applicationId` | `number` | Sim | O ID da application. | | `data` | `{ name: string; user_agent: string }` | Sim | `name` dá nome ao grupo, e `user_agent` contém a expressão regular, como `Mobile\|Android\|iPhone`. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Retorna `data` como o [AzionDeviceGroup](#aziondevicegroup) criado. A API recusa um `name` que contenha um espaço ou um hífen. A função então retorna `error` com a mensagem `HTTP error! Status: 400 - BAD REQUEST`. ```typescript import { createDeviceGroup } from 'azion/applications'; const applicationId = 1234567890; // Replace with the actual application ID // Create a new device group const deviceGroupData = { name: 'MobileDevices', user_agent: 'Mobile|Android|iPhone', }; const { data: newDeviceGroup, error } = await createDeviceGroup({ applicationId, data: deviceGroupData }); if (error) { console.error('Error creating device group:', error); } else { console.log('Device group created successfully:', newDeviceGroup); } ``` Saída: ```text Device group created successfully: { id: 1234, name: 'MobileDevices', user_agent: 'Mobile|Android|iPhone' } ``` --- ## getDeviceGroups Lista os device groups de uma application, uma página por vez. ```typescript function getDeviceGroups(params: { applicationId: number; params?: ApiListDeviceGroupsParams; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | --------------- | --------------------------------------------------- | ----------- | -------------------------------- | | `applicationId` | `number` | Sim | O ID da application. | | `params` | [`ApiListDeviceGroupsParams`](#parametros-de-lista) | Não | Paginação: `page` e `page_size`. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Retorna um [AzionApplicationCollectionResponse](#azionapplicationcollectionresponse) cujo `data.results` contém objetos [AzionDeviceGroup](#aziondevicegroup). ```typescript import { getDeviceGroups } from 'azion/applications'; const applicationId = 1234567890; // Replace with the actual application ID const { data: deviceGroups, error } = await getDeviceGroups({ applicationId, params: { page: 1, page_size: 20 } }); if (error) { console.error('Error listing device groups:', error); } else { console.log(`Found ${deviceGroups?.count} device groups:`, deviceGroups?.results); } ``` Saída: ```text Found 1 device groups: [ { id: 1234, name: 'MobileDevices', user_agent: 'Mobile|Android|iPhone' } ] ``` --- ## getDeviceGroup Retorna um device group de uma application pelo ID dele. ```typescript function getDeviceGroup(params: { applicationId: number; deviceGroupId: number; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | --------------- | ------------------------------------------- | ----------- | --------------------- | | `applicationId` | `number` | Sim | O ID da application. | | `deviceGroupId` | `number` | Sim | O ID do device group. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Retorna `data` como um [AzionDeviceGroup](#aziondevicegroup). ```typescript import { getDeviceGroup } from 'azion/applications'; const applicationId = 1234567890; // Replace with the actual application ID const deviceGroupId = 1234; // Replace with the actual device group ID const { data: deviceGroup, error } = await getDeviceGroup({ applicationId, deviceGroupId }); if (error) { console.error('Error retrieving device group:', error); } else { console.log('Device group details:', deviceGroup); } ``` Saída: ```text Device group details: { id: 1234, name: 'MobileDevices', user_agent: 'Mobile|Android|iPhone' } ``` --- ## updateDeviceGroup Envia em uma requisição `PATCH` os campos do device group que você passa. O novo `name` segue a mesma regra da criação: sem espaços e sem hífens. ```typescript function updateDeviceGroup(params: { applicationId: number; deviceGroupId: number; data: ApiUpdateDeviceGroupPayload; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | --------------- | ------------------------------------------- | ----------- | --------------------------------- | | `applicationId` | `number` | Sim | O ID da application. | | `deviceGroupId` | `number` | Sim | O ID do device group a atualizar. | | `data` | `{ name?: string; user_agent?: string }` | Sim | Os campos a mudar. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Retorna `data` como o [AzionDeviceGroup](#aziondevicegroup) atualizado. ```typescript import { updateDeviceGroup } from 'azion/applications'; const applicationId = 1234567890; // Replace with the actual application ID const deviceGroupId = 1234; // Replace with the actual device group ID const { data: updatedDeviceGroup, error } = await updateDeviceGroup({ applicationId, deviceGroupId, data: { name: 'MobileAndTablets', user_agent: 'Mobile|Android|iPhone|iPad' }, }); if (error) { console.error('Error updating device group:', error); } else { console.log('Device group updated:', updatedDeviceGroup); } ``` Saída: ```text Device group updated: { id: 1234, name: 'MobileAndTablets', user_agent: 'Mobile|Android|iPhone|iPad' } ``` --- ## deleteDeviceGroup Exclui um device group de uma application pelo ID dele. ```typescript function deleteDeviceGroup(params: { applicationId: number; deviceGroupId: number; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | --------------- | ------------------------------------------- | ----------- | ------------------------------- | | `applicationId` | `number` | Sim | O ID da application. | | `deviceGroupId` | `number` | Sim | O ID do device group a excluir. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Uma exclusão bem-sucedida retorna `error` com a mensagem `Expected JSON response, but got: `, por isso o exemplo lê o device group de volta com [getDeviceGroup](#getdevicegroup). Um erro `404` confirma a exclusão. ```typescript import { deleteDeviceGroup, getDeviceGroup } from 'azion/applications'; const applicationId = 1234567890; // Replace with the actual application ID const deviceGroupId = 1234; // Replace with the actual device group ID const { error: deleteError } = await deleteDeviceGroup({ applicationId, deviceGroupId }); // On success (HTTP 204) the envelope still carries an error, so confirm by reading it back const { error } = await getDeviceGroup({ applicationId, deviceGroupId }); if (error) { console.log(`Device group ${deviceGroupId} deleted (read back: ${error.message})`); } else { console.error('Error deleting device group:', deleteError); } ``` Saída: ```text Device group 1234 deleted (read back: HTTP error! Status: 404 - NOT FOUND) ``` --- ## createFunctionInstance Cria uma instância de function em uma application. Uma instância executa uma [function](/pt-br/documentacao/plataforma/functions/) existente para essa application, com os argumentos que a instância define. Duas coisas precisam existir antes. A application precisa ter functions ativadas, o que [patchApplication](#patchapplication) faz com `data: { edge_functions: true }`. A function também precisa existir: a instância a identifica pelo ID dela em `edge_function_id`, e o pacote `azion` não tem um módulo que crie functions. ```typescript function createFunctionInstance(params: { applicationId: number; data: ApiCreateFunctionInstancePayload; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | --------------- | ----------------------------------------------------------------------- | ----------- | --------------------------------------------------------------------------- | | `applicationId` | `number` | Sim | O ID da application. | | `data` | [`ApiCreateFunctionInstancePayload`](#apicreatefunctioninstancepayload) | Sim | `name`, o `edge_function_id` da function e os `args` que a function recebe. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Retorna `data` como a [AzionFunctionInstance](#azionfunctioninstance) criada, com o `id` dela. ```typescript import { createFunctionInstance } from 'azion/applications'; const applicationId = 1234567890; // Replace with the actual application ID // Define the data for the new function instance const functionInstanceData = { name: 'my-function-instance', edge_function_id: 23456, // Replace with the ID of an existing function args: { greeting: 'hello' }, }; // Create a new function instance const { data: newFunctionInstance, error } = await createFunctionInstance({ applicationId, data: functionInstanceData }); if (error) { console.error('Error creating function instance:', error); } else { console.log('Function instance created successfully:', newFunctionInstance); } ``` Saída: ```text Function instance created successfully: { edge_function_id: 23456, name: 'my-function-instance', args: { greeting: 'hello' }, id: 12345 } ``` --- ## getFunctionInstances Lista as instâncias de function de uma application, uma página por vez. ```typescript function getFunctionInstances(params: { applicationId: number; params?: ApiListFunctionInstancesParams; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | --------------- | -------------------------------------------------------- | ----------- | -------------------------------- | | `applicationId` | `number` | Sim | O ID da application. | | `params` | [`ApiListFunctionInstancesParams`](#parametros-de-lista) | Não | Paginação: `page` e `page_size`. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Retorna um [AzionApplicationCollectionResponse](#azionapplicationcollectionresponse) cujo `data.results` contém objetos [AzionFunctionInstance](#azionfunctioninstance). ```typescript import { getFunctionInstances } from 'azion/applications'; const applicationId = 1234567890; // Replace with the actual application ID const { data: functionInstances, error } = await getFunctionInstances({ applicationId, params: { page: 1, page_size: 10 }, }); if (error) { console.error('Error listing function instances:', error); } else { console.log(`Found ${functionInstances?.count} function instances:`, functionInstances?.results); } ``` Saída: ```text Found 1 function instances: [ { id: 12345, edge_function_id: 23456, name: 'my-function-instance', args: { greeting: 'hello' } } ] ``` --- ## getFunctionInstance Retorna uma instância de function de uma application pelo ID dela. ```typescript function getFunctionInstance(params: { applicationId: number; functionInstanceId: number; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | -------------------- | ------------------------------------------- | ----------- | ------------------------------ | | `applicationId` | `number` | Sim | O ID da application. | | `functionInstanceId` | `number` | Sim | O ID da instância de function. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Retorna `data` como uma [AzionFunctionInstance](#azionfunctioninstance). ```typescript import { getFunctionInstance } from 'azion/applications'; const applicationId = 1234567890; // Replace with the actual application ID const functionInstanceId = 12345; // Replace with the actual function instance ID const { data: functionInstance, error } = await getFunctionInstance({ applicationId, functionInstanceId }); if (error) { console.error('Error retrieving function instance:', error); } else { console.log('Function instance details:', functionInstance); } ``` Saída: ```text Function instance details: { id: 12345, edge_function_id: 23456, name: 'my-function-instance', args: { greeting: 'hello' } } ``` --- ## updateFunctionInstance Envia em uma requisição `PATCH` os campos da instância de function que você passa. ```typescript function updateFunctionInstance(params: { applicationId: number; functionInstanceId: number; data: ApiUpdateFunctionInstancePayload; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | -------------------- | ------------------------------------------------------------ | ----------- | ------------------------------------------ | | `applicationId` | `number` | Sim | O ID da application. | | `functionInstanceId` | `number` | Sim | O ID da instância de function a atualizar. | | `data` | [`ApiUpdateFunctionInstancePayload`](#azionfunctioninstance) | Sim | Os campos a mudar. O exemplo muda `name`. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Retorna `data` como a [AzionFunctionInstance](#azionfunctioninstance) atualizada. ```typescript import { updateFunctionInstance } from 'azion/applications'; const applicationId = 1234567890; // Replace with the actual application ID const functionInstanceId = 12345; // Replace with the actual function instance ID const { data: updatedFunctionInstance, error } = await updateFunctionInstance({ applicationId, functionInstanceId, data: { name: 'my-function-instance-updated' }, }); if (error) { console.error('Error updating function instance:', error); } else { console.log('Function instance updated:', updatedFunctionInstance); } ``` Saída: ```text Function instance updated: { id: 12345, edge_function_id: 23456, name: 'my-function-instance-updated', args: { greeting: 'hello' } } ``` --- ## deleteFunctionInstance Exclui uma instância de function de uma application pelo ID dela. ```typescript function deleteFunctionInstance(params: { applicationId: number; functionInstanceId: number; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | -------------------- | ------------------------------------------- | ----------- | ---------------------------------------- | | `applicationId` | `number` | Sim | O ID da application. | | `functionInstanceId` | `number` | Sim | O ID da instância de function a excluir. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Uma exclusão bem-sucedida retorna `error` com a mensagem `Expected JSON response, but got: `, por isso o exemplo lê a instância de volta com [getFunctionInstance](#getfunctioninstance). Um erro `404` confirma a exclusão. ```typescript import { deleteFunctionInstance, getFunctionInstance } from 'azion/applications'; const applicationId = 1234567890; // Replace with the actual application ID const functionInstanceId = 12345; // Replace with the actual function instance ID const { error: deleteError } = await deleteFunctionInstance({ applicationId, functionInstanceId }); // On success (HTTP 204) the envelope still carries an error, so confirm by reading it back const { error } = await getFunctionInstance({ applicationId, functionInstanceId }); if (error) { console.log(`Function instance ${functionInstanceId} deleted (read back: ${error.message})`); } else { console.error('Error deleting function instance:', deleteError); } ``` Saída: ```text Function instance 12345 deleted (read back: HTTP error! Status: 404 - NOT FOUND) ``` --- ## createRule Cria uma regra do Rules Engine de uma application, na fase de requisição ou na fase de resposta. ```typescript function createRule(params: { applicationId: number; phase: "request" | "response"; data: ApiCreateRulePayload; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | --------------- | ----------------------------------------------- | ----------- | --------------------------------------------------- | | `applicationId` | `number` | Sim | O ID da application. | | `phase` | `'request' \| 'response'` | Sim | A fase em que a regra é executada. | | `data` | [`ApiCreateRulePayload`](#apicreaterulepayload) | Sim | A regra: `name`, `phase`, `criteria` e `behaviors`. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | `criteria` é uma lista de grupos de condições, e cada grupo é uma lista de condições com `variable`, `operator`, `conditional` e `input_value`. `behaviors` lista as ações, cada uma com um `name` e um `target`. Para as variáveis, os operadores e os nomes de behaviors que uma regra pode usar, consulte [Rules Engine para Applications](/pt-br/documentacao/plataforma/applications/rules-engine/). Retorna `data` como a [AzionRule](#azionrule) criada, com o `id` e a `order` dela. No exemplo, `as const` mantém os tipos literais de que `phase` e `conditional` precisam no TypeScript. ```typescript import { createRule } from 'azion/applications'; const applicationId = 1234567890; // Replace with the actual application ID // Define the data for the new rule const ruleData = { name: 'Example Rule', phase: 'request' as const, criteria: [[{ variable: '${uri}', operator: 'starts_with', conditional: 'if' as const, input_value: '/example-path' }]], behaviors: [{ name: 'redirect_to_301', target: 'https://example.com' }], }; // Create a new rule in the request phase const { data: newRule, error } = await createRule({ applicationId, phase: 'request', data: ruleData }); if (error) { console.error('Error creating rule:', error); } else { console.log('Created rule:', JSON.stringify(newRule)); } ``` Saída: ```text Created rule: {"id":123457,"name":"Example Rule","phase":"request","behaviors":[{"name":"redirect_to_301","target":"https://example.com"}],"criteria":[[{"variable":"${uri}","operator":"starts_with","conditional":"if","input_value":"/example-path"}]],"is_active":true,"order":1,"description":""} ``` --- ## getRules Lista as regras de uma fase de uma application, uma página por vez. ```typescript function getRules(params: { applicationId: number; phase: "request" | "response"; params?: ApiListRulesParams; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | --------------- | -------------------------------------------- | ----------- | -------------------------------- | | `applicationId` | `number` | Sim | O ID da application. | | `phase` | `'request' \| 'response'` | Sim | A fase a listar. | | `params` | [`ApiListRulesParams`](#parametros-de-lista) | Não | Paginação: `page` e `page_size`. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Retorna um [AzionApplicationCollectionResponse](#azionapplicationcollectionresponse) cujo `data.results` contém objetos [AzionRule](#azionrule). A lista de `request` também contém `Default Rule`, a regra da fase `default` que uma application já tem ao ser criada. ```typescript import { getRules } from 'azion/applications'; const applicationId = 1234567890; // Replace with the actual application ID const { data: rules, error } = await getRules({ applicationId, phase: 'request', params: { page: 1, page_size: 10 } }); if (error) { console.error('Error listing rules:', error); } else { console.log(`Found ${rules?.count} rules:`, rules?.results.map((r) => `${r.id} ${r.name} (${r.phase}, order ${r.order})`)); } ``` Saída: ```text Found 2 rules: [ '123456 Default Rule (default, order 1)', '123457 Example Rule (request, order 1)' ] ``` --- ## getRule Retorna uma regra de uma application pela fase e pelo ID dela. ```typescript function getRule(params: { applicationId: number; phase: "request" | "response"; ruleId: number; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | --------------- | ------------------------------------------- | ----------- | --------------------- | | `applicationId` | `number` | Sim | O ID da application. | | `phase` | `'request' \| 'response'` | Sim | A fase da regra. | | `ruleId` | `number` | Sim | O ID da regra. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Retorna `data` como uma [AzionRule](#azionrule). ```typescript import { getRule } from 'azion/applications'; const applicationId = 1234567890; // Replace with the actual application ID const ruleId = 123457; // Replace with the actual rule ID const { data: rule, error } = await getRule({ applicationId, phase: 'request', ruleId }); if (error) { console.error('Error retrieving rule:', error); } else { console.log('Rule details:', JSON.stringify(rule)); } ``` Saída: ```text Rule details: {"id":123457,"name":"Example Rule","phase":"request","behaviors":[{"name":"redirect_to_301","target":"https://example.com"}],"criteria":[[{"variable":"${uri}","operator":"starts_with","conditional":"if","input_value":"/example-path"}]],"is_active":true,"order":1,"description":""} ``` --- ## updateRule Envia em uma requisição `PATCH` os campos da regra que você passa. Os campos que você deixa de fora mantêm os valores: uma chamada que não envia `criteria` mantém os `criteria` da regra sem mudança. ```typescript function updateRule(params: { applicationId: number; phase: "request" | "response"; ruleId: number; data: ApiUpdateRulePayload; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | --------------- | ----------------------------------------------- | ----------- | ----------------------------------------- | | `applicationId` | `number` | Sim | O ID da application. | | `phase` | `'request' \| 'response'` | Sim | A fase da regra. | | `ruleId` | `number` | Sim | O ID da regra a atualizar. | | `data` | [`ApiUpdateRulePayload`](#apicreaterulepayload) | Sim | Os campos a mudar. Todo campo é opcional. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Retorna `data` como a [AzionRule](#azionrule) atualizada. ```typescript import { updateRule } from 'azion/applications'; const applicationId = 1234567890; // Replace with the actual application ID const ruleId = 123457; // Replace with the actual rule ID const { data: updatedRule, error } = await updateRule({ applicationId, phase: 'request', ruleId, data: { name: 'Example Rule Updated', behaviors: [{ name: 'redirect_to_302', target: 'https://example.com/new' }] }, }); if (error) { console.error('Error updating rule:', error); } else { console.log('Updated rule:', JSON.stringify(updatedRule)); } ``` Saída: ```text Updated rule: {"id":123457,"name":"Example Rule Updated","phase":"request","behaviors":[{"name":"redirect_to_302","target":"https://example.com/new"}],"criteria":[[{"variable":"${uri}","operator":"starts_with","conditional":"if","input_value":"/example-path"}]],"is_active":true,"order":1,"description":""} ``` --- ## deleteRule Exclui uma regra de uma application pela fase e pelo ID dela. ```typescript function deleteRule(params: { applicationId: number; phase: "request" | "response"; ruleId: number; options?: AzionClientOptions; }): Promise>; ``` | Parâmetro | Tipo | Obrigatório | Descrição | | --------------- | ------------------------------------------- | ----------- | ------------------------ | | `applicationId` | `number` | Sim | O ID da application. | | `phase` | `'request' \| 'response'` | Sim | A fase da regra. | | `ruleId` | `number` | Sim | O ID da regra a excluir. | | `options` | [`AzionClientOptions`](#azionclientoptions) | Não | Opções de requisição. | Uma exclusão bem-sucedida retorna `error` com a mensagem `Expected JSON response, but got: `, por isso o exemplo lê a regra de volta com [getRule](#getrule). Um erro `404` confirma a exclusão. ```typescript import { deleteRule, getRule } from 'azion/applications'; const applicationId = 1234567890; // Replace with the actual application ID const ruleId = 123457; // Replace with the actual rule ID const { error: deleteError } = await deleteRule({ applicationId, phase: 'request', ruleId }); // On success (HTTP 204) the envelope still carries an error, so confirm by reading it back const { error } = await getRule({ applicationId, phase: 'request', ruleId }); if (error) { console.log(`Rule ${ruleId} deleted (read back: ${error.message})`); } else { console.error('Error deleting rule:', deleteError); } ``` Saída: ```text Rule 123457 deleted (read back: HTTP error! Status: 404 - NOT FOUND) ``` --- ## Métodos da application Uma application que [createApplication](#createapplication) ou [getApplication](#getapplication) retorna carrega as funções dos sub-recursos como métodos, já vinculados ao ID dela. Cada método recebe o mesmo objeto que a função correspondente, sem `applicationId`. Os métodos de regra ficam em `rules.request` e `rules.response`, que também fixam a `phase`. | Propriedade | Tipo | Métodos | | --------------------------------- | ----------------------- | --------------------------------------------------------------------------------------------------------------------------- | | `origins` | `OriginOperations` | `createOrigin`, `getOrigins`, `getOrigin`, `updateOrigin`, `deleteOrigin` | | `cache` | `CacheOperations` | `createCacheSetting`, `getCacheSettings`, `getCacheSetting`, `updateCacheSetting`, `deleteCacheSetting` | | `devices` | `DeviceGroupOperations` | `createDeviceGroup`, `getDeviceGroups`, `getDeviceGroup`, `updateDeviceGroup`, `deleteDeviceGroup` | | `functions` | `FunctionOperations` | `createFunctionInstance`, `getFunctionInstances`, `getFunctionInstance`, `updateFunctionInstance`, `deleteFunctionInstance` | | `rules.request`, `rules.response` | `RuleOperations` | `createRule`, `getRules`, `getRule`, `updateRule`, `deleteRule` | Um método de lista precisa de um objeto como argumento, mesmo vazio: `{}`. Este exemplo lê uma application e lista cada um dos sub-recursos dela pelos métodos: ```typescript import { getApplication } from 'azion/applications'; const applicationId = 1234567890; // Replace with the actual application ID // The application object carries the sub-resource operations, already bound to its ID const { data: app, error } = await getApplication({ applicationId }); if (!app) throw new Error(error?.message); const { data: cache } = await app.cache.getCacheSettings({}); console.log('app.cache.getCacheSettings:', cache?.results.map((c) => c.name)); const { data: origins } = await app.origins.getOrigins({}); console.log('app.origins.getOrigins:', origins?.results.map((o) => o.name)); const { data: rules } = await app.rules.request.getRules({}); console.log('app.rules.request.getRules:', rules?.results.map((r) => r.name)); const { data: devices } = await app.devices.getDeviceGroups({}); console.log('app.devices.getDeviceGroups:', devices?.count); const { data: functions } = await app.functions.getFunctionInstances({}); console.log('app.functions.getFunctionInstances:', functions?.count); ``` Saída: ```text app.cache.getCacheSettings: [ 'my-other-cache-setting' ] app.origins.getOrigins: [ 'my-origin-updated' ] app.rules.request.getRules: [ 'Default Rule' ] app.devices.getDeviceGroups: 0 app.functions.getFunctionInstances: 0 ``` --- ## Erros As funções de nível de application lançam estas mensagens dentro de um `Error`. As outras funções as retornam em `error.message`, e `error.operation` nomeia a chamada, como `create device group`. | Mensagem | Causa | O que fazer | | ---------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `HTTP error! Status: 401 - UNAUTHORIZED` | Nenhum token válido chegou à chamada: `AZION_TOKEN` não está definida ou contém um token inválido, e nenhum `token` de client foi passado. | Defina `AZION_TOKEN` com um [personal token](/pt-br/documentacao/fundamentos/personal-tokens/) válido ou passe `token` para [createAzionApplicationClient](#createazionapplicationclient). | | `HTTP error! Status: 404 - NOT FOUND` | Nenhuma application tem esse ID, ou a application não contém nenhum objeto com esse ID ou essa chave de origem. | Verifique o ID com a função de lista correspondente, como [getApplications](#getapplications) ou [getOrigins](#getorigins). | | `HTTP error! Status: 400 - BAD REQUEST` | A API v3 recusou o payload. A mensagem não traz o motivo que a API informa. As causas incluem `application_acceleration` em uma requisição de criação, um cache setting em uma application sem origem, um nome de device group com um espaço ou um hífen, e `sort` ou `order` em uma lista de cache settings. | Compare o payload com a seção da função que você chamou e remova ou mude o campo que ela indica. | | `Expected JSON response, but got: ` | Uma exclusão foi bem-sucedida, e a API respondeu com um corpo vazio. | Leia o objeto de volta. Um erro `404` confirma a exclusão. | --- ## Tipos O módulo `azion/applications` exporta estes tipos, exceto onde um tipo diz o contrário. Importe-os com `import type`. ### AzionApplicationsClient O client que [createAzionApplicationClient](#createazionapplicationclient) retorna. Cada método recebe um único objeto. | Método | Argumento | Retorno | | ------------------- | ----------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- | | `createApplication` | `{ data: ApiCreateApplicationPayload; options?: AzionClientOptions }` | `Promise>` | | `getApplication` | `{ applicationId: number; options?: AzionClientOptions }` | `Promise>` | | `getApplications` | `{ params?: AzionApplicationCollectionOptions; options?: AzionClientOptions }` | `Promise>` | | `putApplication` | `{ applicationId: number; data: ApiUpdateApplicationPayload; options?: AzionClientOptions }` | `Promise>` | | `patchApplication` | `{ applicationId: number; data: Partial; options?: AzionClientOptions }` | `Promise>` | | `deleteApplication` | `{ applicationId: number; options?: AzionClientOptions }` | `Promise>` | ### CreateAzionApplicationClient O tipo de [createAzionApplicationClient](#createazionapplicationclient). ```typescript type CreateAzionApplicationClient = (config?: Partial<{ token: string; options?: AzionClientOptions; }>) => AzionApplicationsClient; ``` ### AzionClientOptions Opções de requisição que toda função recebe em `options`. | Propriedade | Tipo | Obrigatório | Descrição | | ----------- | --------- | ----------- | ------------------------------------------------------- | | `debug` | `boolean` | Não | Ativa o modo de debug. | | `force` | `boolean` | Não | Declarado pelo tipo. Nenhum exemplo desta página o usa. | ### AzionApplicationResponse O envelope que toda função retorna, exceto as funções de lista. Para saber como lê-lo, consulte [Envelope de resposta](#envelope-de-resposta). | Propriedade | Tipo | Obrigatório | Descrição | | ----------- | ---------------------------------------- | ----------- | ---------------------------------------------------------------------------------------- | | `data` | `T` | Não | O resultado da chamada. | | `error` | `{ message: string; operation: string }` | Não | A mensagem de erro e a operação que falhou. Uma exclusão bem-sucedida também o preenche. | ### AzionApplicationCollectionResponse O envelope que as funções de lista retornam. | Propriedade | Tipo | Obrigatório | Descrição | | --------------------- | -------------------------------------------------------- | ----------- | ---------------------------------------------------- | | `data` | `{ count; total_pages; schema_version; links; results }` | Não | A página de resultados. | | `data.count` | `number` | Sim | O número de objetos da lista inteira, não da página. | | `data.total_pages` | `number` | Sim | O número de páginas. | | `data.schema_version` | `number` | Sim | A versão do schema da resposta da API. | | `data.links` | `{ previous: string \| null; next: string \| null }` | Sim | As páginas anterior e seguinte. | | `data.results` | `T[]` | Sim | Os objetos da página. | | `error` | `{ message: string; operation: string }` | Não | A mensagem de erro e a operação que falhou. | ### AzionApplication Uma application: os campos de [ApiBaseApplicationPayload](#apibaseapplicationpayload), mais o ID e os [métodos da application](#metodos-da-application). `AzionApplicationSettings` tem o mesmo formato, sem os métodos. | Propriedade | Tipo | Obrigatório | Descrição | | ----------- | ------------------------------------------------------- | ----------- | ------------------------------------------ | | `id` | `number` | Sim | O ID da application. | | `origins` | `OriginOperations` | Sim | Os métodos de origem. | | `cache` | `CacheOperations` | Sim | Os métodos de cache setting. | | `devices` | `DeviceGroupOperations` | Sim | Os métodos de device group. | | `functions` | `FunctionOperations` | Sim | Os métodos de instância de function. | | `rules` | `{ request: RuleOperations; response: RuleOperations }` | Sim | Os métodos de regra, um conjunto por fase. | ### ApiBaseApplicationPayload As configurações de uma application. `name` é obrigatório, e todos os outros campos são opcionais. `ApiCreateApplicationPayload`, que o módulo não exporta, tem o mesmo formato, e `ApiUpdateApplicationPayload` torna todos os campos opcionais. A API v3 recusa `application_acceleration` em uma requisição de criação. ```typescript interface ApiBaseApplicationPayload { name: string; delivery_protocol?: DeliveryProtocol; http3?: boolean; http_port?: HttpPort[]; https_port?: HttpsPort[]; minimum_tls_version?: TlsVersion; active?: boolean; debug_rules?: boolean; application_acceleration?: boolean; caching?: boolean; device_detection?: boolean; edge_firewall?: boolean; edge_functions?: boolean; image_optimization?: boolean; l2_caching?: boolean; load_balancer?: boolean; raw_logs?: boolean; web_application_firewall?: boolean; supported_ciphers?: SupportedCiphers; } ``` Os enums das configurações da application, que o módulo exporta: ```typescript enum DeliveryProtocol { HTTP = "http", HTTPS = "https", HTTP_HTTPS = "http,https" } enum HttpPort { PORT_80 = 80, PORT_8008 = 8008, PORT_8080 = 8080 } enum HttpsPort { PORT_443 = 443, PORT_8443 = 8443, PORT_9440 = 9440, PORT_9441 = 9441, PORT_9442 = 9442, PORT_9443 = 9443 } enum TlsVersion { TLS_1_0 = "tls_1_0", TLS_1_1 = "tls_1_1", TLS_1_2 = "tls_1_2", TLS_1_3 = "tls_1_3" } enum SupportedCiphers { ALL = "all", TLSv1_2_2018 = "TLSv1.2_2018", TLSv1_2_2019 = "TLSv1.2_2019", TLSv1_2_2021 = "TLSv1.2_2021", TLSv1_3_2022 = "TLSv1.3_2022" } ``` ### ApiListApplicationsParams Paginação e ordenação para [getApplications](#getapplications). `AzionApplicationCollectionOptions`, que o método do client recebe, tem as mesmas chaves. | Propriedade | Tipo | Obrigatório | Descrição | | ----------- | ---------------- | ----------- | ------------------------------------------------------- | | `page` | `number` | Não | O número da página. | | `page_size` | `number` | Não | O número de applications por página. | | `sort` | `'name' \| 'id'` | Não | Declarado pelo tipo. Nenhum exemplo desta página o usa. | | `order_by` | `string` | Não | Declarado pelo tipo. Nenhum exemplo desta página o usa. | ### AzionOrigin Uma origem, com a `origin_key` dela. `ApiCreateOriginPayload` recebe todos os campos abaixo, exceto `id` e `method`, todos obrigatórios, além dos campos opcionais `origin_path`, `hmac_authentication`, `hmac_region_name`, `hmac_access_key`, `hmac_secret_key`, `connection_timeout` e `timeout_between_bytes`. `ApiUpdateOriginRequest` torna todos os campos opcionais e exige `id`. ```typescript interface AzionOrigin { id: number; origin_key: string; name: string; origin_type: OriginType; addresses: Address[]; origin_protocol_policy: OriginProtocolPolicy; is_origin_redirection_enabled: boolean; host_header: string; method: string; origin_path: string; connection_timeout: number; timeout_between_bytes: number; hmac_authentication: boolean; hmac_region_name: string; hmac_access_key: string; hmac_secret_key: string; } interface Address { address: string; weight?: number | null; server_role?: ServerRole; is_active?: boolean; } ``` Os enums de uma origem, que o módulo não exporta: ```typescript enum OriginType { SINGLE_ORIGIN = "single_origin", LOAD_BALANCER = "load_balancer" } enum OriginProtocolPolicy { PRESERVE = "preserve", HTTP = "http", HTTPS = "https" } enum ServerRole { PRIMARY = "primary", BACKUP = "backup" } ``` ### AzionCacheSetting Um cache setting: os campos de [ApiBaseCacheSettingPayload](#apibasecachesettingpayload), mais o `id` dele (`number`). ### ApiBaseCacheSettingPayload As configurações de um cache setting. `name` é obrigatório, e todos os outros campos são opcionais. `ApiUpdateCacheSettingPayload` torna todos os campos opcionais. ```typescript interface ApiBaseCacheSettingPayload { name: string; browser_cache_settings?: BrowserCacheSettings; browser_cache_settings_maximum_ttl?: number; cdn_cache_settings?: CdnCacheSettings; cdn_cache_settings_maximum_ttl?: number; cache_by_query_string?: CacheByQueryString; query_string_fields?: string[]; enable_query_string_sort?: boolean; cache_by_cookies?: CacheByCookies; cookie_names?: string[]; adaptive_delivery_action?: AdaptiveDeliveryAction; device_group?: string[]; enable_caching_for_post?: boolean; l2_caching_enabled?: boolean; is_slice_configuration_enabled?: boolean; is_slice_edge_caching_enabled?: boolean; is_slice_l2_caching_enabled?: boolean; slice_configuration_range?: number; enable_caching_for_options?: boolean; enable_stale_cache?: boolean; l2_region?: string | null; } ``` Os enums de um cache setting, que o módulo não exporta: ```typescript enum BrowserCacheSettings { HONOR = "honor", OVERRIDE = "override", IGNORE = "ignore" } enum CdnCacheSettings { HONOR = "honor", OVERRIDE = "override" } enum CacheByQueryString { IGNORE = "ignore", WHITELIST = "whitelist", BLACKLIST = "blacklist", ALL = "all" } enum CacheByCookies { IGNORE = "ignore", WHITELIST = "whitelist", BLACKLIST = "blacklist", ALL = "all" } enum AdaptiveDeliveryAction { IGNORE = "ignore", OPTIMIZE = "optimize" } ``` ### AzionDeviceGroup Um device group. `ApiCreateDeviceGroupPayload` e `ApiUpdateDeviceGroupPayload`, que o módulo não exporta, recebem `name` e `user_agent`, ambos obrigatórios na criação e opcionais na atualização. | Propriedade | Tipo | Obrigatório | Descrição | | ------------ | -------- | ----------- | ---------------------------------------------------------------------- | | `id` | `number` | Sim | O ID do device group. | | `name` | `string` | Sim | O nome do grupo, sem espaços e sem hífens. | | `user_agent` | `string` | Sim | A expressão regular comparada com o header de requisição `User-Agent`. | ### AzionFunctionInstance Uma instância de function. A API retorna os quatro campos abaixo, como os exemplos mostram. | Propriedade | Tipo | Descrição | | ------------------ | ------------------------- | ----------------------------------------- | | `id` | `number` | O ID da instância de function. | | `edge_function_id` | `number` | O ID da function que a instância executa. | | `name` | `string` | O nome da instância de function. | | `args` | `Record` | Os argumentos que a function recebe. | O tipo declara outros campos: `id`, mais os campos de `ApiBaseFunctionInstancePayload`, que são `name`, `code`, `language` (`'JavaScript'`), `initiator_type` (`'edge_application' \| 'edge_firewall'`), `active` e `json_args`. `ApiUpdateFunctionInstancePayload` torna esses campos opcionais. ### ApiCreateFunctionInstancePayload O payload de [createFunctionInstance](#createfunctioninstance). O módulo não exporta este tipo. | Propriedade | Tipo | Obrigatório | Descrição | | ------------------ | ------------------------- | ----------- | ------------------------------------------------------- | | `name` | `string` | Sim | O nome da instância de function. | | `edge_function_id` | `number` | Sim | O ID da function que a instância executa. | | `args` | `Record` | Sim | Os argumentos que a function recebe. | | `active` | `boolean` | Não | Declarado pelo tipo. Nenhum exemplo desta página o usa. | ### AzionRule Uma regra: os campos de [ApiCreateRulePayload](#apicreaterulepayload), mais `id` (`number`). `AzionRule` declara `is_active` e `order` como obrigatórios, e toda regra dos exemplos traz os dois. ### ApiCreateRulePayload O payload de [createRule](#createrule). `ApiUpdateRulePayload` torna todos os campos opcionais. | Propriedade | Tipo | Obrigatório | Descrição | | ------------- | ------------------------- | ----------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `name` | `string` | Sim | O nome da regra. | | `phase` | `'request' \| 'response'` | Sim | A fase da regra. | | `criteria` | `Criterion[][]` | Sim | Os grupos de condições. Cada `Criterion` contém `variable` (`string`), `operator` (`string`), `conditional` (`'if' \| 'and' \| 'or'`) e `input_value` (`string`). | | `behaviors` | `Behavior[]` | Sim | As ações. Cada `Behavior` contém `name` (`string`) e um `target` opcional: uma `string`, `null` ou `{ captured_array: string; subject: string; regex: string }`. | | `is_active` | `boolean` | Não | Indica se a regra está ativa. Uma regra criada sem ele fica ativa. | | `order` | `number` | Não | A posição da regra na fase dela. | | `description` | `string` | Não | A descrição da regra. | ### Parâmetros de lista O objeto `params` de cada função de lista de sub-recurso declara estas chaves. Os exemplos enviam apenas `page` e `page_size`. `ApiListDeviceGroupsParams` não é exportado. | Tipo | Chaves declaradas | | -------------------------------- | ------------------------------------------------------------------------------------------------- | | `ApiListOriginsParams` | `page`, `page_size`, `sort` (`'name' \| 'id'`), `order` (`'asc' \| 'desc'`), `filter` | | `ApiListCacheSettingsParams` | `page`, `page_size`, `sort` (`'name' \| 'id'`), `order` (`'asc' \| 'desc'`) | | `ApiListDeviceGroupsParams` | `page`, `page_size`, `sort` (`'name' \| 'id'`), `order` (`'asc' \| 'desc'`) | | `ApiListFunctionInstancesParams` | `page`, `page_size`, `sort` (`'name' \| 'id'`), `order` (`'asc' \| 'desc'`), `order_by`, `filter` | | `ApiListRulesParams` | `page`, `page_size`, `sort` (`string`), `order` (`'asc' \| 'desc'`), `filter` | --- ## Recursos relacionados - [Azion Lib](/pt-br/documentacao/devtools/azion-lib.md): Os módulos da Azion Lib e o pacote npm em que cada um é distribuído. - [Client](/pt-br/documentacao/devtools/azion-lib/client.md): O client que expõe Applications ao lado de Storage, SQL, Purge, Domains e AI. - [Domains](/pt-br/documentacao/devtools/azion-lib/domains.md): As funções da Azion Lib que apontam um domínio para uma application pelo ID dela. - [Applications | v3](/pt-br/documentacao/plataforma/applications/v3.md): A application da API v3, com os protocolos de entrega, as portas e as configurações dela.