Regras

As funções do azion/applications que criam, listam, leem, atualizam e excluem as regras de uma fase da application.

Última atualização

Ver como Markdown Configurar agente

Uma regra pertence ao Rules Engine de uma application, na fase de requisição ou na fase de resposta. Estas funções do azion/applications criam, listam, leem, atualizam e excluem essas regras, e cada uma recebe a fase como phase.

createRule

Cria uma regra do Rules Engine de uma application, na fase de requisição ou na fase de resposta.

TypeScript
01function createRule(params: {
02 applicationId: number;
03 phase: "request" | "response";
04 data: ApiCreateRulePayload;
05 options?: AzionClientOptions;
06}): Promise<AzionApplicationResponse<AzionRule>>;
ParâmetroTipoObrigatórioDescrição
applicationIdnumberSimO ID da application.
phase'request' | 'response'SimA fase em que a regra é executada.
dataApiCreateRulePayloadSimA regra: name, phase, criteria e behaviors.
optionsAzionClientOptionsNãoOpçõ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.

Retorna data como a 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
01import { createRule } from 'azion/applications';
02
03const applicationId = 1234567890; // Replace with the actual application ID
04
05// Define the data for the new rule
06const ruleData = {
07 name: 'Example Rule',
08 phase: 'request' as const,
09 criteria: [[{ variable: '${uri}', operator: 'starts_with', conditional: 'if' as const, input_value: '/example-path' }]],
10 behaviors: [{ name: 'redirect_to_301', target: 'https://example.com' }],
11};
12
13// Create a new rule in the request phase
14const { data: newRule, error } = await createRule({ applicationId, phase: 'request', data: ruleData });
15
16if (error) {
17 console.error('Error creating rule:', error);
18} else {
19 console.log('Created rule:', JSON.stringify(newRule));
20}

Saída:

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
01function getRules(params: {
02 applicationId: number;
03 phase: "request" | "response";
04 params?: ApiListRulesParams;
05 options?: AzionClientOptions;
06}): Promise<AzionApplicationCollectionResponse<AzionRule>>;
ParâmetroTipoObrigatórioDescrição
applicationIdnumberSimO ID da application.
phase'request' | 'response'SimA fase a listar.
paramsApiListRulesParamsNãoPaginação: page e page_size.
optionsAzionClientOptionsNãoOpções de requisição.

Retorna um AzionApplicationCollectionResponse cujo data.results contém objetos 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
01import { getRules } from 'azion/applications';
02
03const applicationId = 1234567890; // Replace with the actual application ID
04
05const { data: rules, error } = await getRules({ applicationId, phase: 'request', params: { page: 1, page_size: 10 } });
06
07if (error) {
08 console.error('Error listing rules:', error);
09} else {
10 console.log(`Found ${rules?.count} rules:`, rules?.results.map((r) => `${r.id} ${r.name} (${r.phase}, order ${r.order})`));
11}

Saída:

Texto
01Found 2 rules: [
02 '123456 Default Rule (default, order 1)',
03 '123457 Example Rule (request, order 1)'
04]

getRule

Retorna uma regra de uma application pela fase e pelo ID dela.

TypeScript
01function getRule(params: {
02 applicationId: number;
03 phase: "request" | "response";
04 ruleId: number;
05 options?: AzionClientOptions;
06}): Promise<AzionApplicationResponse<AzionRule>>;
ParâmetroTipoObrigatórioDescrição
applicationIdnumberSimO ID da application.
phase'request' | 'response'SimA fase da regra.
ruleIdnumberSimO ID da regra.
optionsAzionClientOptionsNãoOpções de requisição.

Retorna data como uma AzionRule.

TypeScript
01import { getRule } from 'azion/applications';
02
03const applicationId = 1234567890; // Replace with the actual application ID
04const ruleId = 123457; // Replace with the actual rule ID
05
06const { data: rule, error } = await getRule({ applicationId, phase: 'request', ruleId });
07
08if (error) {
09 console.error('Error retrieving rule:', error);
10} else {
11 console.log('Rule details:', JSON.stringify(rule));
12}

Saída:

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
01function updateRule(params: {
02 applicationId: number;
03 phase: "request" | "response";
04 ruleId: number;
05 data: ApiUpdateRulePayload;
06 options?: AzionClientOptions;
07}): Promise<AzionApplicationResponse<AzionRule>>;
ParâmetroTipoObrigatórioDescrição
applicationIdnumberSimO ID da application.
phase'request' | 'response'SimA fase da regra.
ruleIdnumberSimO ID da regra a atualizar.
dataApiUpdateRulePayloadSimOs campos a mudar. Todo campo é opcional.
optionsAzionClientOptionsNãoOpções de requisição.

Retorna data como a AzionRule atualizada.

TypeScript
01import { updateRule } from 'azion/applications';
02
03const applicationId = 1234567890; // Replace with the actual application ID
04const ruleId = 123457; // Replace with the actual rule ID
05
06const { data: updatedRule, error } = await updateRule({
07 applicationId,
08 phase: 'request',
09 ruleId,
10 data: { name: 'Example Rule Updated', behaviors: [{ name: 'redirect_to_302', target: 'https://example.com/new' }] },
11});
12
13if (error) {
14 console.error('Error updating rule:', error);
15} else {
16 console.log('Updated rule:', JSON.stringify(updatedRule));
17}

Saída:

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
01function deleteRule(params: {
02 applicationId: number;
03 phase: "request" | "response";
04 ruleId: number;
05 options?: AzionClientOptions;
06}): Promise<AzionApplicationResponse<void>>;
ParâmetroTipoObrigatórioDescrição
applicationIdnumberSimO ID da application.
phase'request' | 'response'SimA fase da regra.
ruleIdnumberSimO ID da regra a excluir.
optionsAzionClientOptionsNãoOpçõ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. Um erro 404 confirma a exclusão.

TypeScript
01import { deleteRule, getRule } from 'azion/applications';
02
03const applicationId = 1234567890; // Replace with the actual application ID
04const ruleId = 123457; // Replace with the actual rule ID
05
06const { error: deleteError } = await deleteRule({ applicationId, phase: 'request', ruleId });
07
08// On success (HTTP 204) the envelope still carries an error, so confirm by reading it back
09const { error } = await getRule({ applicationId, phase: 'request', ruleId });
10if (error) {
11 console.log(`Rule ${ruleId} deleted (read back: ${error.message})`);
12} else {
13 console.error('Error deleting rule:', deleteError);
14}

Saída:

Rule 123457 deleted (read back: HTTP error! Status: 404 - NOT FOUND)

Recursos relacionados

Azion Lib

Os módulos da Azion Lib e o pacote npm em que cada um é distribuído.

Applications

A autenticação do módulo, o envelope de resposta dele e os erros que as funções reportam.

Tipos de application

Os tipos de payload e de resposta que estas funções recebem e retornam.

Rules Engine

As fases de uma application e os critérios e behaviors que uma regra carrega.