drools-builder 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,543 @@
+/**
+ * Typed enum for every constraint operator supported by Drools.
+ * Values are the exact DRL tokens, so an Operator member is directly
+ * assignable to the ConstraintOperator string-literal union in types.ts.
+ *
+ * @example
+ *   fact('Player', '$p').field('score', Operator.Gte, '100')
+ */
+declare enum Operator {
+    Eq = "==",
+    Neq = "!=",
+    Gt = ">",
+    Lt = "<",
+    Gte = ">=",
+    Lte = "<=",
+    Contains = "contains",
+    NotContains = "not contains",
+    MemberOf = "memberOf",
+    NotMemberOf = "not memberOf",
+    Matches = "matches",
+    NotMatches = "not matches"
+}
+/**
+ * Typed enum for the built-in Drools accumulate functions.
+ * Use these as the second argument to AccumulateBuilder.fn().
+ *
+ * @example
+ *   accumulate(fact('Transaction', '$tx'))
+ *     .fn('$total', Aggregate.Sum, '$tx.amount')
+ */
+declare enum Aggregate {
+    Sum = "sum",
+    Count = "count",
+    Min = "min",
+    Max = "max",
+    Average = "average",
+    CollectList = "collectList",
+    CollectSet = "collectSet",
+    CountDistinct = "countDistinct"
+}
+
+type ConstraintOperator = '==' | '!=' | '>' | '<' | '>=' | '<=' | 'contains' | 'not contains' | 'memberOf' | 'not memberOf' | 'matches' | 'not matches';
+interface FieldConstraint {
+    kind: 'FieldConstraint';
+    field: string;
+    operator: ConstraintOperator;
+    value: string;
+    binding?: string;
+}
+interface BindingConstraint {
+    kind: 'BindingConstraint';
+    binding: string;
+    field: string;
+}
+interface RawConstraint {
+    kind: 'RawConstraint';
+    expression: string;
+}
+type Constraint = FieldConstraint | BindingConstraint | RawConstraint;
+type FactType = string;
+interface FactPattern {
+    kind: 'FactPattern';
+    factType: FactType;
+    binding?: string;
+    constraints: Constraint[];
+}
+interface UnboundPattern {
+    kind: 'UnboundPattern';
+    factType: FactType;
+    constraints: Constraint[];
+}
+interface AndCondition {
+    kind: 'And';
+    conditions: Condition[];
+}
+interface OrCondition {
+    kind: 'Or';
+    conditions: Condition[];
+}
+interface NotCondition {
+    kind: 'Not';
+    condition: UnboundPattern | EvalCondition | RawCondition;
+}
+interface ExistsCondition {
+    kind: 'Exists';
+    condition: UnboundPattern | EvalCondition | RawCondition;
+}
+interface ForallCondition {
+    kind: 'Forall';
+    condition: Condition;
+}
+interface AccumulateFunction {
+    binding: string;
+    function: string;
+    argument: string;
+}
+interface AccumulatePattern {
+    kind: 'Accumulate';
+    source: Condition;
+    functions: AccumulateFunction[];
+    resultConstraint?: string;
+}
+interface FromCondition {
+    kind: 'From';
+    pattern: FactPattern;
+    expression: string;
+}
+interface EvalCondition {
+    kind: 'Eval';
+    expression: string;
+}
+interface RawCondition {
+    kind: 'RawCondition';
+    drl: string;
+}
+type Condition = FactPattern | UnboundPattern | AndCondition | OrCondition | NotCondition | ExistsCondition | ForallCondition | AccumulatePattern | FromCondition | EvalCondition | RawCondition;
+interface Modification {
+    method: string;
+    args: string[];
+}
+interface ModifyConsequence {
+    kind: 'ModifyConsequence';
+    binding: string;
+    modifications: Modification[];
+}
+interface InsertConsequence {
+    kind: 'InsertConsequence';
+    objectExpression: string;
+}
+interface RetractConsequence {
+    kind: 'RetractConsequence';
+    binding: string;
+}
+interface SetGlobalConsequence {
+    kind: 'SetGlobalConsequence';
+    expression: string;
+}
+interface RawConsequence {
+    kind: 'RawConsequence';
+    code: string;
+}
+type Consequence = ModifyConsequence | InsertConsequence | RetractConsequence | SetGlobalConsequence | RawConsequence;
+interface Rule {
+    name: string;
+    salience?: number;
+    agendaGroup?: string;
+    noLoop?: boolean;
+    lockOnActive?: boolean;
+    ruleFlowGroup?: string;
+    conditions: Condition[];
+    consequences: Consequence[];
+}
+interface DroolsFile {
+    name: string;
+    imports: string[];
+    rules: Rule[];
+}
+
+/**
+ * Chainable builder for a FactPattern (a bound or unbound pattern in the LHS).
+ *
+ * Create via the fact() factory function:
+ *   fact('Player', '$p').field('score', Operator.Gte, '100')
+ */
+declare class PatternBuilder {
+    private readonly _factType;
+    private readonly _binding;
+    private readonly _constraints;
+    constructor(factType: string, binding?: string);
+    /**
+     * Add a field constraint: field operator value.
+     * Optionally binds the result to a variable: $v : field op value.
+     */
+    field(field: string, operator: ConstraintOperator, value: string, binding?: string): this;
+    /** Bind a field to a variable: $binding : field */
+    bind(binding: string, field: string): this;
+    /** Emit a verbatim DRL constraint expression. */
+    raw(expression: string): this;
+    build(): FactPattern;
+}
+/**
+ * Chainable builder for an UnboundPattern (used inside not() and exists()
+ * where Drools forbids variable bindings).
+ *
+ * Create via the unbound() factory function:
+ *   not(unbound('FraudAlert').field('status', Operator.Eq, '"UNRESOLVED"'))
+ */
+declare class UnboundPatternBuilder {
+    private readonly _factType;
+    private readonly _constraints;
+    constructor(factType: string);
+    field(field: string, operator: ConstraintOperator, value: string): this;
+    raw(expression: string): this;
+    build(): UnboundPattern;
+}
+
+/**
+ * Chainable builder for an AccumulatePattern.
+ *
+ * Create via the accumulate() factory function:
+ *
+ *   accumulate(fact('Transaction', '$tx').field('amount', Operator.Gt, '0'))
+ *     .fn('$total', Aggregate.Sum, '$tx.amount')
+ *     .resultConstraint('$total > 1000')
+ */
+declare class AccumulateBuilder {
+    private readonly _source;
+    private readonly _functions;
+    private _resultConstraint?;
+    constructor(source: Condition);
+    /**
+     * Register an accumulate function.
+     * @param binding   - the variable the result is bound to, e.g. '$total'
+     * @param func      - function name or Aggregate enum, e.g. Aggregate.Sum / 'collectList'
+     * @param argument  - the argument expression, e.g. '$tx.amount'
+     */
+    fn(binding: string, func: Aggregate | string, argument: string): this;
+    /** Optional result constraint applied to the accumulated value, e.g. '$total > 50' */
+    resultConstraint(expression: string): this;
+    build(): AccumulatePattern;
+}
+
+/**
+ * Chainable builder for a ModifyConsequence.
+ *
+ * Create via the modify() factory function:
+ *
+ *   modify('$account')
+ *     .call('setStatus', 'Account.Status.FROZEN')
+ *     .call('setRemarks', '"Frozen by rule"')
+ */
+declare class ModifyBuilder {
+    private readonly _binding;
+    private readonly _modifications;
+    constructor(binding: string);
+    /** Call a setter/method on the bound fact with the given arguments. */
+    call(method: string, ...args: string[]): this;
+    build(): ModifyConsequence;
+}
+
+/**
+ * Restricted builder for the inner condition of not() and exists().
+ * Drools only allows UnboundPattern, eval(), or raw DRL inside these wrappers.
+ */
+declare class InnerPatternBuilder {
+    private _inner?;
+    fact(factType: string, fn?: (p: UnboundPatternBuilder) => void): this;
+    eval(expression: string): this;
+    raw(drl: string): this;
+    /** @internal */
+    _build(): UnboundPattern | EvalCondition | RawCondition;
+}
+/**
+ * Imperative builder for the when-block of a rule.
+ * Obtained via RuleBuilder.when(lhs => { ... }).
+ *
+ * Every method returns `this` for optional chaining.
+ */
+declare class LHSBuilder {
+    /** @internal collected conditions — consumed by RuleBuilder */
+    readonly _conditions: Condition[];
+    /** Add a FactPattern with an optional variable binding. */
+    fact(factType: string, binding: string, fn?: (p: PatternBuilder) => void): this;
+    fact(factType: string, fn?: (p: PatternBuilder) => void): this;
+    /** Add a not() wrapper. Inner condition must be unbound (no variable binding). */
+    not(fn: (b: InnerPatternBuilder) => void): this;
+    /** Add an exists() wrapper. Inner condition must be unbound. */
+    exists(fn: (b: InnerPatternBuilder) => void): this;
+    /** Add an or() group. Each child is added via the nested LHSBuilder. */
+    or(fn: (lhs: LHSBuilder) => void): this;
+    /** Add an and() group. Useful when composing nested boolean logic. */
+    and(fn: (lhs: LHSBuilder) => void): this;
+    /** Add a forall() wrapper. */
+    forall(fn: (lhs: LHSBuilder) => void): this;
+    /**
+     * Add an accumulate pattern.
+     * @param sourceFn - builds the source condition (the pattern being accumulated)
+     * @param fn       - configures the accumulate functions and result constraint
+     */
+    accumulate(sourceFn: (lhs: LHSBuilder) => void, fn: (acc: AccumulateBuilder) => void): this;
+    /**
+     * Add a from condition: FactType( constraints ) from expression
+     * @param factType   - the type to match
+     * @param binding    - variable binding for the matched fact
+     * @param expression - the source expression (collection, method call, etc.)
+     * @param fn         - optional constraint configuration
+     */
+    from(factType: string, binding: string, expression: string, fn?: (p: PatternBuilder) => void): this;
+    /** Add an eval() condition with a raw boolean expression. */
+    eval(expression: string): this;
+    /** Add a verbatim DRL condition, emitted as-is. */
+    raw(drl: string): this;
+}
+
+/**
+ * Imperative builder for the then-block of a rule.
+ * Obtained via RuleBuilder.then(rhs => { ... }).
+ */
+declare class RHSBuilder {
+    /** @internal collected consequences — consumed by RuleBuilder */
+    readonly _consequences: Consequence[];
+    /** modify($binding) { ... } — calls setters on an existing fact. */
+    modify(binding: string, fn: (m: ModifyBuilder) => void): this;
+    /** insert(objectExpression) — inserts a new fact into working memory. */
+    insert(objectExpression: string): this;
+    /** retract($binding) — removes a fact from working memory. */
+    retract(binding: string): this;
+    /** Assign a value to a global variable. */
+    global(expression: string): this;
+    /** Emit a verbatim DRL statement, emitted as-is. */
+    raw(code: string): this;
+}
+
+interface Buildable$1<T> {
+    build(): T;
+}
+/**
+ * Fluent builder for a Drools Rule.
+ *
+ * Entry point: createRule(name)
+ *
+ * Two usage styles are supported and can be freely mixed:
+ *
+ * Style 1 — factory functions (composable, works well for complex rules):
+ *   createRule('Award Badge')
+ *     .salience(10)
+ *     .addCondition(fact('Player', '$p').field('score', Operator.Gte, '100'))
+ *     .addConsequence(modify('$p').call('awardBadge', '"gold"'))
+ *     .build()
+ *
+ * Style 2 — callback blocks (mirrors DRL when/then structure):
+ *   createRule('Award Badge')
+ *     .salience(10)
+ *     .when(lhs => {
+ *       lhs.fact('Player', '$p', p => p.field('score', Operator.Gte, '100'))
+ *     })
+ *     .then(rhs => {
+ *       rhs.modify('$p', m => m.call('awardBadge', '"gold"'))
+ *     })
+ *     .build()
+ *
+ * Plain metamodel objects are also accepted everywhere a builder is expected,
+ * so hand-crafted conditions/consequences can be mixed freely with builders.
+ */
+declare class RuleBuilder {
+    private readonly _rule;
+    constructor(name: string);
+    salience(value: number): this;
+    agendaGroup(value: string): this;
+    /** Defaults to true when called without an argument. */
+    noLoop(value?: boolean): this;
+    /** Defaults to true when called without an argument. */
+    lockOnActive(value?: boolean): this;
+    ruleFlowGroup(value: string): this;
+    /**
+     * Append a single condition.
+     * Accepts a plain Condition object or any builder that exposes build().
+     */
+    addCondition(condition: Condition | Buildable$1<Condition>): this;
+    /**
+     * Append a single consequence.
+     * Accepts a plain Consequence object or any builder that exposes build().
+     */
+    addConsequence(consequence: Consequence | Buildable$1<Consequence>): this;
+    /** Configure the when-block using an LHSBuilder. Appends to existing conditions. */
+    when(fn: (lhs: LHSBuilder) => void): this;
+    /** Configure the then-block using an RHSBuilder. Appends to existing consequences. */
+    then(fn: (rhs: RHSBuilder) => void): this;
+    build(): Rule;
+}
+/** Create a new RuleBuilder for a rule with the given name. */
+declare function createRule(name: string): RuleBuilder;
+
+/**
+ * Chainable builder for a DroolsFile (a collection of rules with shared imports).
+ *
+ * Create via the createFile() factory:
+ *
+ *   createFile('fraud-rules')
+ *     .import('com.example.model.Account')
+ *     .import('com.example.model.FraudAlert')
+ *     .addRule(
+ *       createRule('Detect Fraud').when(...).then(...),
+ *     )
+ *     .build()
+ */
+declare class DroolsFileBuilder {
+    private readonly _name;
+    private readonly _imports;
+    private readonly _rules;
+    constructor(name: string);
+    /**
+     * Add a fully-qualified Java class import.
+     * Can be called multiple times — order is preserved.
+     *
+     * @example
+     *   .import('com.example.model.Player')
+     */
+    import(className: string): this;
+    /**
+     * Add a rule to the file.
+     * Accepts a plain Rule object or a RuleBuilder (auto-resolved via .build()).
+     *
+     * @example
+     *   .addRule(createRule('My Rule').when(...).then(...))
+     *   .addRule({ name: 'My Rule', conditions: [], consequences: [] })
+     */
+    addRule(rule: Rule | RuleBuilder): this;
+    build(): DroolsFile;
+}
+/** Create a new DroolsFileBuilder with the given file name. */
+declare function createFile(name: string): DroolsFileBuilder;
+
+/**
+ * drools-builder — public API
+ *
+ * Import from this module to access both the metamodel types and the builder API.
+ */
+
+interface Buildable<T> {
+    build(): T;
+}
+type NotExistsInput = UnboundPattern | EvalCondition | RawCondition | Buildable<UnboundPattern>;
+/**
+ * Start building a FactPattern.
+ *
+ * @param factType - the Java class name to match (e.g. 'Player')
+ * @param binding  - optional variable binding (e.g. '$p')
+ *
+ * @example
+ *   fact('Player', '$p').field('score', Operator.Gte, '100')
+ */
+declare function fact(factType: string, binding?: string): PatternBuilder;
+/**
+ * Start building an UnboundPattern for use inside not() or exists().
+ *
+ * @example
+ *   not(unbound('FraudAlert').field('status', Operator.Eq, '"UNRESOLVED"'))
+ */
+declare function unbound(factType: string): UnboundPatternBuilder;
+/**
+ * Wrap a condition in a Drools not().
+ * The inner condition must be unbound (UnboundPatternBuilder / UnboundPattern),
+ * an eval(), or a raw condition.
+ */
+declare function not(condition: NotExistsInput): NotCondition;
+/**
+ * Wrap a condition in a Drools exists().
+ * Same constraints as not().
+ */
+declare function exists(condition: NotExistsInput): ExistsCondition;
+/**
+ * Group conditions with OR semantics.
+ *
+ * @example
+ *   or(fact('A').field('x', Operator.Eq, '1'), fact('B').field('y', Operator.Eq, '2'))
+ */
+declare function or(...conditions: Array<Condition | Buildable<Condition>>): OrCondition;
+/**
+ * Group conditions with AND semantics.
+ * Mostly used when building nested boolean logic inside or().
+ */
+declare function and(...conditions: Array<Condition | Buildable<Condition>>): AndCondition;
+/**
+ * Wrap a condition in a Drools forall().
+ *
+ * @example
+ *   forall(fact('Transaction', '$tx').field('validated', Operator.Eq, 'true'))
+ */
+declare function forall(condition: Condition | Buildable<Condition>): ForallCondition;
+/**
+ * Start building an AccumulatePattern.
+ *
+ * @example
+ *   accumulate(fact('Transaction', '$tx').field('amount', Operator.Gt, '0'))
+ *     .fn('$total', Aggregate.Sum, '$tx.amount')
+ *     .resultConstraint('$total > 1000')
+ */
+declare function accumulate(source: Condition | Buildable<Condition>): AccumulateBuilder;
+/**
+ * Build a FromCondition: pattern from expression.
+ *
+ * @example
+ *   from_(fact('Transaction', '$tx'), '$recentTxs')
+ */
+declare function from_(pattern: PatternBuilder, expression: string): FromCondition;
+/**
+ * Build an EvalCondition with a raw boolean expression.
+ *
+ * @example
+ *   eval_('$p.getScore() > threshold')
+ */
+declare function eval_(expression: string): EvalCondition;
+/**
+ * Build a RawCondition — verbatim DRL, emitted as-is.
+ * Use as an escape hatch for constructs not covered by the builder.
+ */
+declare function rawCondition(drl: string): RawCondition;
+/**
+ * Start building a ModifyConsequence.
+ *
+ * @example
+ *   modify('$account').call('setStatus', 'Account.Status.FROZEN')
+ */
+declare function modify(binding: string): ModifyBuilder;
+/**
+ * Build an InsertConsequence — inserts a new fact into working memory.
+ *
+ * @example
+ *   insert('new FraudAlert()')
+ */
+declare function insert(objectExpression: string): InsertConsequence;
+/**
+ * Build a RetractConsequence — removes a fact from working memory.
+ *
+ * @example
+ *   retract('$obsoleteAlert')
+ */
+declare function retract(binding: string): RetractConsequence;
+/**
+ * Build a SetGlobalConsequence — assign a value to a global variable.
+ *
+ * @example
+ *   setGlobal('alertService.notify($account)')
+ */
+declare function setGlobal(expression: string): SetGlobalConsequence;
+/**
+ * Build a RawConsequence — verbatim Java/DRL code, emitted as-is.
+ * Use as an escape hatch for logic not covered by the builder.
+ */
+declare function rawConsequence(code: string): RawConsequence;
+
+declare const DRLToMetaTransformer: {
+    parse(drl: string): DroolsFile;
+    parseRule(block: string): Rule;
+};
+
+declare const MetaToDRLTransformer: {
+    generate(file: DroolsFile): string;
+    generateRule(rule: Rule): string;
+};
+
+export { AccumulateBuilder, type AccumulateFunction, type AccumulatePattern, Aggregate, type AndCondition, type BindingConstraint, type Condition, type Consequence, type Constraint, type ConstraintOperator, DRLToMetaTransformer, type DroolsFile, DroolsFileBuilder, type EvalCondition, type ExistsCondition, type FactPattern, type FactType, type FieldConstraint, type ForallCondition, type FromCondition, type InsertConsequence, LHSBuilder, MetaToDRLTransformer, type Modification, ModifyBuilder, type ModifyConsequence, type NotCondition, Operator, type OrCondition, PatternBuilder, RHSBuilder, type RawCondition, type RawConsequence, type RawConstraint, type RetractConsequence, type Rule, RuleBuilder, type SetGlobalConsequence, type UnboundPattern, UnboundPatternBuilder, accumulate, and, createFile, createRule, eval_, exists, fact, forall, from_, insert, modify, not, or, rawCondition, rawConsequence, retract, setGlobal, unbound };