drools-builder 0.1.2 → 1.0.0

package/README.md

@@ -77,6 +77,7 @@ Plain metamodel objects are accepted everywhere a builder is expected.
 const file = createFile('fraud-rules')
   .import('com.example.Account')
   .import('com.example.FraudAlert')
+  .global('com.example.AlertService', 'alertService')
   .addRule(rule)
   .addRule(createRule('Another Rule').when(...).then(...))
   .build()

package/dist/index.cjs

@@ -430,6 +430,7 @@ function resolveRule(input) {
 var DroolsFileBuilder = class {
   constructor(name) {
     this._imports = [];
+    this._globals = [];
     this._rules = [];
     this._name = name;
   }
@@ -444,6 +445,17 @@ var DroolsFileBuilder = class {
     this._imports.push(className);
     return this;
   }
+  /**
+   * Declare a global variable available to all rules in this file.
+   * Emits `global type name;` in the DRL header.
+   *
+   * @example
+   *   .global('com.example.AlertService', 'alertService')
+   */
+  global(type, name) {
+    this._globals.push({ type, name });
+    return this;
+  }
   /**
    * Add a rule to the file.
    * Accepts a plain Rule object or a RuleBuilder (auto-resolved via .build()).
@@ -460,6 +472,7 @@ var DroolsFileBuilder = class {
     return {
       name: this._name,
       imports: [...this._imports],
+      globals: [...this._globals],
       rules: [...this._rules]
     };
   }
@@ -524,6 +537,144 @@ function rawConsequence(code) {
   return { kind: "RawConsequence", code };
 }
 
+// src/rule-builder/parser/MetaToDRLTransformer.ts
+function generateConstraint(c) {
+  switch (c.kind) {
+    case "FieldConstraint":
+      return `${c.binding ? `${c.binding} : ` : ""}${c.field} ${c.operator} ${c.value}`;
+    case "BindingConstraint":
+      return `${c.binding} : ${c.field}`;
+    case "RawConstraint":
+      return c.expression;
+  }
+}
+function generateCondition(cond, indent = "    ") {
+  switch (cond.kind) {
+    case "FactPattern": {
+      const binding = cond.binding ? `${cond.binding} : ` : "";
+      const constraints = cond.constraints.map(generateConstraint).join(", ");
+      return `${binding}${cond.factType}( ${constraints} )`;
+    }
+    case "UnboundPattern": {
+      const constraints = cond.constraints.map(generateConstraint).join(", ");
+      return `${cond.factType}( ${constraints} )`;
+    }
+    case "And": {
+      const parts = cond.conditions.map((c) => generateCondition(c, indent + "  "));
+      return `( ${parts.join(`
+${indent}  and `)} )`;
+    }
+    case "Or": {
+      const parts = cond.conditions.map((c) => generateCondition(c, indent + "  "));
+      return `( ${parts.join(`
+${indent}  or `)} )`;
+    }
+    case "Not":
+      return `not( ${generateCondition(cond.condition, indent)} )`;
+    case "Exists":
+      return `exists( ${generateCondition(cond.condition, indent)} )`;
+    case "Forall":
+      return `forall( ${generateCondition(cond.condition, indent)} )`;
+    case "Accumulate": {
+      const source = generateCondition(cond.source, indent + "  ");
+      const fns = cond.functions.map((f) => `${f.binding} : ${f.function}( ${f.argument} )`).join(", ");
+      const result = cond.resultConstraint ? `;
+${indent}  ${cond.resultConstraint}` : "";
+      return `accumulate(
+${indent}  ${source};
+${indent}  ${fns}${result}
+${indent})`;
+    }
+    case "From":
+      return `${generateCondition(cond.pattern, indent)} from ${cond.expression}`;
+    case "Eval":
+      return `eval( ${cond.expression} )`;
+    case "RawCondition":
+      return cond.drl;
+  }
+}
+function generateWhenBlock(conditions, indent = "    ") {
+  const flat = conditions.length === 1 && conditions[0].kind === "And" ? conditions[0].conditions : conditions;
+  return flat.map((c) => `${indent}${generateCondition(c, indent)}`).join("\n");
+}
+function generateConsequence(cons, indent = "    ") {
+  switch (cons.kind) {
+    case "ModifyConsequence": {
+      const mods = cons.modifications.map((m) => `${m.method}( ${m.args.join(", ")} )`).join(`,
+${indent}  `);
+      return `modify( ${cons.binding} ) {
+${indent}  ${mods}
+${indent}}`;
+    }
+    case "InsertConsequence":
+      return `insert( ${cons.objectExpression} );`;
+    case "RetractConsequence":
+      return `retract( ${cons.binding} );`;
+    case "SetGlobalConsequence":
+      return `${cons.expression};`;
+    case "RawConsequence":
+      return `${cons.code};`;
+    case "ReturnConsequence":
+      return cons.expression ? `return ${cons.expression};` : "return;";
+    case "IfConsequence": {
+      const thenLines = cons.then.map((c) => `${indent}  ${generateConsequence(c, indent + "  ")}`).join("\n");
+      if (cons.else && cons.else.length > 0) {
+        const elseLines = cons.else.map((c) => `${indent}  ${generateConsequence(c, indent + "  ")}`).join("\n");
+        return `if (${cons.condition}) {
+${thenLines}
+${indent}} else {
+${elseLines}
+${indent}}`;
+      }
+      return `if (${cons.condition}) {
+${thenLines}
+${indent}}`;
+    }
+  }
+}
+function generateDeclaration(decl) {
+  const attrs = decl.attributes.map((a) => `    ${a.name} : ${a.type}`).join("\n");
+  return `declare ${decl.className}${attrs ? "\n" + attrs + "\n" : "\n"}end`;
+}
+function generateFunction(fn, indent = "    ") {
+  const body = fn.body.map((c) => `${indent}${generateConsequence(c, indent)}`).join("\n");
+  return `function ${fn.returnType} ${fn.name}(${fn.params}) {
+${body}
+}`;
+}
+function generateRule(rule) {
+  const lines = [`rule "${rule.name}"`];
+  if (rule.salience !== void 0) lines.push(`  salience ${rule.salience}`);
+  if (rule.agendaGroup !== void 0) lines.push(`  agenda-group "${rule.agendaGroup}"`);
+  if (rule.ruleFlowGroup !== void 0) lines.push(`  ruleflow-group "${rule.ruleFlowGroup}"`);
+  if (rule.noLoop) lines.push("  no-loop true");
+  if (rule.lockOnActive) lines.push("  lock-on-active true");
+  lines.push("  when");
+  lines.push(generateWhenBlock(rule.conditions));
+  lines.push("  then");
+  lines.push(rule.consequences.map((c) => `    ${generateConsequence(c)}`).join("\n"));
+  lines.push("end");
+  return lines.join("\n");
+}
+var MetaToDRLTransformer = {
+  generate(file) {
+    const sections = [];
+    if (file.imports.length > 0)
+      sections.push(file.imports.map((i) => `import ${i};`).join("\n"));
+    if (file.globals.length > 0)
+      sections.push(file.globals.map((g) => `global ${g.type} ${g.name};`).join("\n"));
+    if (file.declarations && file.declarations.length > 0)
+      sections.push(file.declarations.map((d) => generateDeclaration(d)).join("\n\n"));
+    if (file.functions && file.functions.length > 0)
+      sections.push(file.functions.map((fn) => generateFunction(fn)).join("\n\n"));
+    sections.push(file.rules.map(generateRule).join("\n\n"));
+    return sections.join("\n\n");
+  },
+  generateRule(rule) {
+    return generateRule(rule);
+  }
+};
+
 // src/rule-builder/parser/DRLToMetaTransformer.ts
 function indexAtDepth0(text, needle) {
   let depth = 0;
@@ -624,26 +775,63 @@ function parseImports(drl) {
   while ((m = re.exec(drl)) !== null) imports.push(m[1].trim());
   return imports;
 }
+function parseGlobals(drl) {
+  const globals = [];
+  const re = /^\s*global\s+(\S+)\s+(\S+?)\s*;?$/gm;
+  let m;
+  while ((m = re.exec(drl)) !== null) globals.push({ type: m[1], name: m[2] });
+  return globals;
+}
 function extractRuleBlocks(drl) {
   const blocks = [];
-  const re = /\brule\s+"[^"]*"[\s\S]*?\bend\b/g;
+  const re = /\brule\s+(?:"[^"]*"|'[^']*')[\s\S]*?\bend\b/g;
   let m;
   while ((m = re.exec(drl)) !== null) blocks.push(m[0]);
   return blocks;
 }
+function parseFunctions(drl) {
+  const results = [];
+  const re = /\bfunction\s+([\w<>?,\s\[\]]+?)\s+(\w+)\s*\(([^)]*)\)\s*\{([^{}]*(?:\{[^{}]*\}[^{}]*)*)\}/g;
+  let m;
+  while ((m = re.exec(drl)) !== null) {
+    results.push({
+      returnType: m[1].trim(),
+      name: m[2].trim(),
+      params: m[3].trim(),
+      body: parseConsequences(m[4].trim())
+    });
+  }
+  return results;
+}
+function parseDeclarations(drl) {
+  const results = [];
+  const re = /\bdeclare\s+(\w+)\s*([\s\S]*?)\bend\b/g;
+  let m;
+  while ((m = re.exec(drl)) !== null) {
+    const className = m[1].trim();
+    const attributes = [];
+    const attrRe = /^\s*(\w+)\s*:\s*(\S+)/gm;
+    let a;
+    while ((a = attrRe.exec(m[2])) !== null) {
+      attributes.push({ name: a[1].trim(), type: a[2].trim() });
+    }
+    results.push({ className, attributes });
+  }
+  return results;
+}
 function parseRuleName(block) {
-  const m = block.match(/\brule\s+"([^"]+)"/);
-  return m ? m[1] : "unknown";
+  const m = block.match(/\brule\s+(?:"([^"]+)"|'([^']+)')/);
+  return m ? m[1] ?? m[2] : "unknown";
 }
 function parseRuleAttributes(block) {
   const attrs = {};
-  const m = block.match(/\brule\s+"[^"]+"\s*([\s\S]*?)\bwhen\b/);
+  const m = block.match(/\brule\s+(?:"[^"]+"|'[^']+')\s*([\s\S]*?)\bwhen\b/);
   if (!m) return attrs;
   const attr = m[1];
   const salience = attr.match(/\bsalience\s+(-?\d+)/);
   if (salience) attrs.salience = parseInt(salience[1], 10);
-  if (/\bno-loop\s+true\b/.test(attr)) attrs.noLoop = true;
-  if (/\block-on-active\s+true\b/.test(attr)) attrs.lockOnActive = true;
+  if (!/\bno-loop\s+false\b/.test(attr) && /\bno-loop\b/.test(attr)) attrs.noLoop = true;
+  if (!/\block-on-active\s+false\b/.test(attr) && /\block-on-active\b/.test(attr)) attrs.lockOnActive = true;
   const ag = attr.match(/\bagenda-group\s+"([^"]+)"/);
   if (ag) attrs.agendaGroup = ag[1];
   const rfg = attr.match(/\bruleflow-group\s+"([^"]+)"/);
@@ -823,6 +1011,23 @@ function parseConsequences(then) {
 function parseNextConsequence(text) {
   const t = text.trim();
   if (!t) return null;
+  if (/^if\s*\(/.test(t)) {
+    const condition = extractBalanced(t, "(", ")");
+    const afterCond = t.slice(t.indexOf("(") + condition.length + 2).trim();
+    const thenBlock = extractBalanced(afterCond, "{", "}");
+    const thenConsequences = parseConsequences(thenBlock);
+    let afterThen = afterCond.slice(afterCond.indexOf("{") + thenBlock.length + 2).trim();
+    let elseConsequences;
+    if (/^else\s*\{/.test(afterThen)) {
+      const elseBlock = extractBalanced(afterThen, "{", "}");
+      elseConsequences = parseConsequences(elseBlock);
+      afterThen = afterThen.slice(afterThen.indexOf("{") + elseBlock.length + 2).trim();
+    }
+    return {
+      consequence: { kind: "IfConsequence", condition: condition.trim(), then: thenConsequences, ...elseConsequences && { else: elseConsequences } },
+      rest: afterThen
+    };
+  }
   if (/^modify\s*\(/.test(t)) {
     const m = t.match(/^modify\s*\(\s*(\$\w+)\s*\)/);
     if (m) {
@@ -845,6 +1050,14 @@ function parseNextConsequence(text) {
     const rest = t.slice(t.indexOf("(") + inner.length + 2).replace(/^\s*;/, "");
     return { consequence: { kind: "RetractConsequence", binding: inner.trim() }, rest };
   }
+  if (/^return\b/.test(t)) {
+    const semiIdx2 = indexAtDepth0(t, ";");
+    const expression = t.slice("return".length, semiIdx2 !== -1 ? semiIdx2 : void 0).trim();
+    return {
+      consequence: { kind: "ReturnConsequence", expression },
+      rest: semiIdx2 !== -1 ? t.slice(semiIdx2 + 1) : ""
+    };
+  }
   const semiIdx = indexAtDepth0(t, ";");
   if (semiIdx !== -1)
     return { consequence: { kind: "RawConsequence", code: t.slice(0, semiIdx).trim() }, rest: t.slice(semiIdx + 1) };
@@ -863,7 +1076,10 @@ var DRLToMetaTransformer = {
     const clean = stripComments(drl);
     return {
       name: "parsed",
-      imports: parseImports(clean),
+      imports: [...new Set(parseImports(clean))],
+      globals: parseGlobals(clean),
+      declarations: parseDeclarations(clean),
+      functions: parseFunctions(clean),
       rules: extractRuleBlocks(clean).map((block) => DRLToMetaTransformer.parseRule(block))
     };
   },
@@ -876,112 +1092,6 @@ var DRLToMetaTransformer = {
     };
   }
 };
-
-// src/rule-builder/parser/MetaToDRLTransformer.ts
-function generateConstraint(c) {
-  switch (c.kind) {
-    case "FieldConstraint":
-      return `${c.binding ? `${c.binding} : ` : ""}${c.field} ${c.operator} ${c.value}`;
-    case "BindingConstraint":
-      return `${c.binding} : ${c.field}`;
-    case "RawConstraint":
-      return c.expression;
-  }
-}
-function generateCondition(cond, indent = "    ") {
-  switch (cond.kind) {
-    case "FactPattern": {
-      const binding = cond.binding ? `${cond.binding} : ` : "";
-      const constraints = cond.constraints.map(generateConstraint).join(", ");
-      return `${binding}${cond.factType}( ${constraints} )`;
-    }
-    case "UnboundPattern": {
-      const constraints = cond.constraints.map(generateConstraint).join(", ");
-      return `${cond.factType}( ${constraints} )`;
-    }
-    case "And": {
-      const parts = cond.conditions.map((c) => generateCondition(c, indent + "  "));
-      return `( ${parts.join(`
-${indent}  and `)} )`;
-    }
-    case "Or": {
-      const parts = cond.conditions.map((c) => generateCondition(c, indent + "  "));
-      return `( ${parts.join(`
-${indent}  or `)} )`;
-    }
-    case "Not":
-      return `not( ${generateCondition(cond.condition, indent)} )`;
-    case "Exists":
-      return `exists( ${generateCondition(cond.condition, indent)} )`;
-    case "Forall":
-      return `forall( ${generateCondition(cond.condition, indent)} )`;
-    case "Accumulate": {
-      const source = generateCondition(cond.source, indent + "  ");
-      const fns = cond.functions.map((f) => `${f.binding} : ${f.function}( ${f.argument} )`).join(", ");
-      const result = cond.resultConstraint ? `;
-${indent}  ${cond.resultConstraint}` : "";
-      return `accumulate(
-${indent}  ${source};
-${indent}  ${fns}${result}
-${indent})`;
-    }
-    case "From":
-      return `${generateCondition(cond.pattern, indent)} from ${cond.expression}`;
-    case "Eval":
-      return `eval( ${cond.expression} )`;
-    case "RawCondition":
-      return cond.drl;
-  }
-}
-function generateWhenBlock(conditions, indent = "    ") {
-  const flat = conditions.length === 1 && conditions[0].kind === "And" ? conditions[0].conditions : conditions;
-  return flat.map((c) => `${indent}${generateCondition(c, indent)}`).join("\n");
-}
-function generateConsequence(cons, indent = "    ") {
-  switch (cons.kind) {
-    case "ModifyConsequence": {
-      const mods = cons.modifications.map((m) => `${m.method}( ${m.args.join(", ")} )`).join(`,
-${indent}  `);
-      return `modify( ${cons.binding} ) {
-${indent}  ${mods}
-${indent}}`;
-    }
-    case "InsertConsequence":
-      return `insert( ${cons.objectExpression} );`;
-    case "RetractConsequence":
-      return `retract( ${cons.binding} );`;
-    case "SetGlobalConsequence":
-      return `${cons.expression};`;
-    case "RawConsequence":
-      return `${cons.code};`;
-  }
-}
-function generateRule(rule) {
-  const lines = [`rule "${rule.name}"`];
-  if (rule.salience !== void 0) lines.push(`  salience ${rule.salience}`);
-  if (rule.agendaGroup !== void 0) lines.push(`  agenda-group "${rule.agendaGroup}"`);
-  if (rule.ruleFlowGroup !== void 0) lines.push(`  ruleflow-group "${rule.ruleFlowGroup}"`);
-  if (rule.noLoop) lines.push("  no-loop true");
-  if (rule.lockOnActive) lines.push("  lock-on-active true");
-  lines.push("  when");
-  lines.push(generateWhenBlock(rule.conditions));
-  lines.push("  then");
-  lines.push(rule.consequences.map((c) => `    ${generateConsequence(c)}`).join("\n"));
-  lines.push("end");
-  return lines.join("\n");
-}
-var MetaToDRLTransformer = {
-  generate(file) {
-    const sections = [];
-    if (file.imports.length > 0)
-      sections.push(file.imports.map((i) => `import ${i};`).join("\n"));
-    sections.push(file.rules.map(generateRule).join("\n\n"));
-    return sections.join("\n\n");
-  },
-  generateRule(rule) {
-    return generateRule(rule);
-  }
-};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AccumulateBuilder,