Rules

The azion/applications functions that create, list, read, update, and delete the rules of an application phase.

Last updated

View as Markdown Agent setup

A rule belongs to the Rules Engine of an application, in the request phase or the response phase. These azion/applications functions create, list, read, update, and delete those rules, and each one takes the phase as phase.

createRule

Creates a rule of the Rules Engine of an application, in the request phase or the response phase.

TypeScript
01function createRule(params: {
02 applicationId: number;
03 phase: "request" | "response";
04 data: ApiCreateRulePayload;
05 options?: AzionClientOptions;
06}): Promise<AzionApplicationResponse<AzionRule>>;
ParameterTypeRequiredDescription
applicationIdnumberYesThe ID of the application.
phase'request' | 'response'YesThe phase the rule runs in.
dataApiCreateRulePayloadYesThe rule: name, phase, criteria, and behaviors.
optionsAzionClientOptionsNoRequest options.

criteria is a list of condition groups, and each group is a list of conditions with variable, operator, conditional, and input_value. behaviors lists the actions, each with a name and a target. For the variables, operators, and behavior names a rule can use, refer to Rules Engine for Applications.

Returns data as the created AzionRule, with its id and order. In the sample, as const keeps the literal types that phase and conditional need in 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}

Output:

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

Lists the rules of one phase of an application, one page at a time.

TypeScript
01function getRules(params: {
02 applicationId: number;
03 phase: "request" | "response";
04 params?: ApiListRulesParams;
05 options?: AzionClientOptions;
06}): Promise<AzionApplicationCollectionResponse<AzionRule>>;
ParameterTypeRequiredDescription
applicationIdnumberYesThe ID of the application.
phase'request' | 'response'YesThe phase to list.
paramsApiListRulesParamsNoPagination: page and page_size.
optionsAzionClientOptionsNoRequest options.

Returns an AzionApplicationCollectionResponse whose data.results holds AzionRule objects. The request list also holds Default Rule, the rule in phase default that a new application already has.

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}

Output:

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

getRule

Returns one rule of an application by its phase and ID.

TypeScript
01function getRule(params: {
02 applicationId: number;
03 phase: "request" | "response";
04 ruleId: number;
05 options?: AzionClientOptions;
06}): Promise<AzionApplicationResponse<AzionRule>>;
ParameterTypeRequiredDescription
applicationIdnumberYesThe ID of the application.
phase'request' | 'response'YesThe phase of the rule.
ruleIdnumberYesThe ID of the rule.
optionsAzionClientOptionsNoRequest options.

Returns data as an 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}

Output:

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

Sends the rule fields you pass in a PATCH request. Fields you leave out keep their values: a call that does not send criteria leaves the criteria of the rule unchanged.

TypeScript
01function updateRule(params: {
02 applicationId: number;
03 phase: "request" | "response";
04 ruleId: number;
05 data: ApiUpdateRulePayload;
06 options?: AzionClientOptions;
07}): Promise<AzionApplicationResponse<AzionRule>>;
ParameterTypeRequiredDescription
applicationIdnumberYesThe ID of the application.
phase'request' | 'response'YesThe phase of the rule.
ruleIdnumberYesThe ID of the rule to update.
dataApiUpdateRulePayloadYesThe fields to change. Every field is optional.
optionsAzionClientOptionsNoRequest options.

Returns data as the updated AzionRule.

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}

Output:

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

Deletes a rule of an application by its phase and ID.

TypeScript
01function deleteRule(params: {
02 applicationId: number;
03 phase: "request" | "response";
04 ruleId: number;
05 options?: AzionClientOptions;
06}): Promise<AzionApplicationResponse<void>>;
ParameterTypeRequiredDescription
applicationIdnumberYesThe ID of the application.
phase'request' | 'response'YesThe phase of the rule.
ruleIdnumberYesThe ID of the rule to delete.
optionsAzionClientOptionsNoRequest options.

A successful delete returns error with the message Expected JSON response, but got: , so the sample reads the rule back with getRule. A 404 error confirms the delete.

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}

Output:

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

The Azion Lib modules and the npm package each one ships in.

Applications

The module’s authentication, its response envelope, and the errors its functions report.

Application types

The payload and response types these functions take and return.

Rules Engine

The phases of an application and the criteria and behaviors a rule carries.