बिज़नेस रूल्स इंजन

आज़माएं

कोई भी शर्त बदलें. वाक्य, नतीजा और व्याख्या साथ-साथ बदलेंगे.

1. 01

   इंस्टॉल करें

   जो चाहिए वही लें. इंजन और उसकी शब्दावली की कोई रनटाइम डिपेंडेंसी नहीं है; बिल्डर अलग पैकेज है क्योंकि सिर्फ़ रूल चलाने वाले सर्वर को React एडिटर भेजने की ज़रूरत नहीं.

   terminalकॉपी करें

   # the engine and its vocabulary
   pnpm add @adysre/rules-core @adysre/rules-types
   
   # the visual builder, when you want one
   pnpm add @adysre/rules-ui @adysre/rules-react @adysre/rules-theme

2. 02

   रूल लिखें

   रूल सादा JSON है. बिल्डर आईडी और टाइमस्टैम्प संभालते हैं, पर आप ऑब्जेक्ट खुद भी लिख सकते हैं, स्टोर कर सकते हैं और रिव्यू में डिफ़ कर सकते हैं.

   rules/large-orders.tsकॉपी करें

   import { all, condition, field, literal, rule } from '@adysre/rules-core';
   
   // A rule is plain JSON. The builders exist so ids and timestamps are handled
   // for you, but nothing stops you writing the object by hand.
   const largeOrders = rule({
     name: 'Large orders from new customers need approval',
     kind: 'validation',
     when: all([
       condition({
         left: field('order.total'),
         operator: 'greaterThan',
         args: [literal(1000)],
       }),
     ]),
     then: [{ id: 'a_hold', type: 'requireApproval' }],
   });

3. 03

   चलाएं

   सिंक्रोनस और शुद्ध. रजिस्ट्री खाली शुरू होती है क्योंकि रूल क्या कर सकते हैं यह आपका निर्णय है. नतीजे में वर्डिक्ट, एक्शन और ट्रेस मिलते हैं.

   rules/run.tsकॉपी करें

   import { builtinPlugins, createContext, createRegistry, evaluateRule } from '@adysre/rules-core';
   
   // The registry starts EMPTY: what rules may do is your choice. Pass the
   // built-ins for the usual twenty-seven operators and twenty-three functions.
   const registry = createRegistry(builtinPlugins);
   
   const outcome = evaluateRule(registry, largeOrders, createContext(order));
   
   outcome.verdict;      // 'matched' | 'unmatched' | 'skipped' | 'errored'
   outcome.actions;      // what to do — the engine never does it for you
   outcome.trace;        // every node that ran, and what it concluded

4. 04

   वापस पढ़ें

   हर रूल एक वाक्य बनता है, जो ट्री से बनता है और कभी वापस पार्स नहीं होता. पहले संरचना, फिर टेक्स्ट.

   rules/explain.tsकॉपी करें

   import { describeRule } from '@adysre/rules-renderer';
   
   describeRule(largeOrders, { plugins: registry }).text;
   // When order total is greater than 1,000
   // Then require approval
   
   // Structure first, text second: `.lines` gives typed segments, so a UI can
   // highlight the field being edited or colour the condition that decided it.

5. 05

   अपना ऑपरेटर जोड़ें

   इंजन जो कुछ करता है वह प्लगइन है. रजिस्टर करें और बिल्डर उसे दिखाएगा, डीबगर समझाएगा, और रूल सादा JSON ही रहेंगे.

   rules/registry.tsकॉपी करें

   import { createRegistry, builtinPlugins, RuleError } from '@adysre/rules-core';
   import type { OperatorPlugin } from '@adysre/rules-types';
   
   // Your own operator. The builder picks it up, the debugger explains it, and
   // your rules stay plain JSON — no change to the engine.
   const withinBusinessHours: OperatorPlugin = {
     id: 'withinBusinessHours',
     labelKey: 'operators.withinBusinessHours',
     arity: 0,
     accepts: ['date'],
     evaluate: (left) => {
       if (typeof left !== 'string') {
         // Not `false`: a broken comparison must not look like a failed one.
         throw new RuleError('type_mismatch', 'withinBusinessHours needs a date.');
       }
       const hour = new Date(left).getHours();
       return hour >= 9 && hour < 17;
     },
   };
   
   const registry = createRegistry(builtinPlugins, { operators: [withinBusinessHours] });

6. 06

   संपादन दें

   विज़ुअल बिल्डर पूरी तरह प्लगइन मेटाडेटा से चलता है: arity तय करता है कितने बॉक्स दिखें, accepts तय करता है कौन-से ऑपरेटर मिलें.

   app/editor.tsxकॉपी करें

   'use client';
   
   import { RuleBuilder } from '@adysre/rules-ui';
   
   export function Editor({ rule, onChange }) {
     return (
       <RuleBuilder
         rule={rule}
         registry={registry}
         sample={sampleOrder}   // runs the rule as you type
         onChange={onChange}
       />
     );
   }

7. 07

   कारण जानें

   डीबगर बताता है किस पंक्ति ने नतीजा तय किया, और शॉर्ट-सर्किट बंद करके दोबारा चलाकर छिपी खराबियां सामने लाता है.

   rules/debug.tsकॉपी करें

   import { debugRule } from '@adysre/rules-devtools';
   
   const session = debugRule(registry, largeOrders, createContext(order));
   
   session.decision;                  // which row decided, or that several did
   session.comparison.hiddenErrors;   // faults a short circuit stepped over

8. 08

   सहेजें

   वर्ज़निंग और रीस्टोर के साथ एक स्टोरेज कॉन्ट्रैक्ट. रीस्टोर नया वर्ज़न लिखता है, इतिहास मिटाता नहीं.

   rules/storage.tsकॉपी करें

   import { createMemoryStorage, runStorageConformance } from '@adysre/rules-storage';
   
   const storage = createMemoryStorage();
   await storage.save(largeOrders);          // version 1
   await storage.restore(largeOrders.id, 1); // a NEW version holding version 1
   
   // Writing your own adapter? Check it against the same contract:
   const results = await runStorageConformance(() => createMyAdapter());

पैकेज

हर पैकेज उसी चरण में आता है जब उसका काम बनता है. जो चाहिए वही इंस्टॉल करें.