@ dedgerules/ 节点

边缘规则决定服务 节点.js二号舰:

安装

npm install @edgerules/node @edgerules/portable

需要节点.js 18或更后(仅ESM).

生产用途

从边框规则 DSL 字符串装入

import { DecisionService } from '@edgerules/node';

const service = new DecisionService(`{
    applicant: {
        age:    <number, required: true>
        income: <number, default: 0>
    }
    isEligible: applicant.age >= 18 and applicant.income >= 1000
}`);

// Execute the whole model — inputs are bound via a model-shaped request object
const result = service.execute('*', { applicant: { age: 25, income: 2500 } });
// { applicant: { age: 25, income: 2500 }, isEligible: true }

从便携式JSON型号装入

import { DecisionService } from '@edgerules/node';
import type { PortableContext } from '@edgerules/portable';

const model: PortableContext = {
  '@kind': 'context',
  fields: {
    taxRate: 0.21,
    calculateTax: {
      '@kind': 'method',
      parameters: { amount: 'number', rate: 'number' },
      body: { '@kind': 'context', fields: { result: 'amount * rate' } },
    },
  },
};

const service = new DecisionService(model);

// Execute a specific function — pass its arguments as request bindings
const tax = service.execute('calculateTax', { amount: 100, rate: 0.21 });
// { result: 21 }

执行规则集

const service = new DecisionService(`{
    ruleset risk(age: number, income: number): {
        hitPolicy: "first-match"
        rules: [
            { when: { age: 18..25, income: < 30000 }, then: { level: "high",   limit: 1000  } }
            { when: { age: 18..25, income: >= 30000 }, then: { level: "medium", limit: 5000  } }
            { when: { age: > 25 },                     then: { level: "low",    limit: 20000 } }
        ]
        default: { level: "none", limit: 0 }
    }
    decision: risk(age: applicant.age, income: applicant.income)
}`);

const result = service.execute('decision', { applicant: { age: 23, income: 25000 } });
// { level: "high", limit: 1000 }

处理错误

每个执行或模型错误都是结构化的 PortableError - 从来不是普通的弦.

import { DecisionService } from '@edgerules/node';
import type { PortableError } from '@edgerules/portable';

try {
  service.execute('unknownField');
} catch (err) {
  const error = err as PortableError;
  console.error(error.type);     // "EntryNotFound"
  console.error(error.message);  // human-readable, safe to surface
  console.error(error.path);     // "unknownField"
}

可变/ 开发用法

使用 ./mutable 要访问的子路径导入 MutableDecisionService,它添加了 CRUD 操作在行执行后. 这个构件用于IDEs,规则编辑器,以及测试工具- 没有 用于生产交通.

import { MutableDecisionService } from '@edgerules/node/mutable';

const service = new MutableDecisionService(`{
    taxRate: 0.21
    tax: amount * taxRate
}`);

// Read a node enriched with linked type information
const node = service.get('taxRate');
// { "@kind": "expression", "expression": "0.21", "type": "number", "linked": true }

// Update a field at runtime — the engine relinks lazily on the next execute
service.set('taxRate', 0.25);

// Read the entire model snapshot
const model = service.get('*');

// Add a new typed input
service.set('amount', { '@kind': 'placeholder', type: 'number', required: true });

// Remove a field
service.remove('taxRate');

// Rename a field
service.rename('tax', 'vat');

// Read a node as DSL source text instead of Portable JSON
service.getCode('tax');
// 'amount * taxRate'

// Write DSL source text back — returns a PortableNode, not code text
service.setCode('tax', 'amount * taxRate * 2');

get 类型

import { Kinds } from '@edgerules/node';

// Absent kinds: every declaration, with bodies
service.get('isEligible');

// The method signature only
service.get('isEligible', ['method-interface']);

// The type only, without its facts
service.get('Customer', ['type']);

// A project-explorer view without bodies and expression text
service.get('*', [...Kinds.EXPRESSION_INTERFACES, ...Kinds.TYPES, ...Kinds.INVOCABLE_INTERFACES]);

API 参考

DecisionService

MutableDecisionService (德文建设)

继承 execute 并添加:

相关软件包

• @edgerules/web ——浏览器使用相同的 API
• @edgerules/portable - 便携式JSON类型定义