drools-builder 0.1.2 → 0.1.3

package/dist/index.js

@@ -375,6 +375,7 @@ function resolveRule(input) {
 var DroolsFileBuilder = class {
   constructor(name) {
     this._imports = [];
+    this._globals = [];
     this._rules = [];
     this._name = name;
   }
@@ -389,6 +390,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()).
@@ -405,6 +417,7 @@ var DroolsFileBuilder = class {
     return {
       name: this._name,
       imports: [...this._imports],
+      globals: [...this._globals],
       rules: [...this._rules]
     };
   }
@@ -469,6 +482,114 @@ 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};`;
+  }
+}
+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"));
+    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;
@@ -569,6 +690,13 @@ 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;
@@ -809,6 +937,7 @@ var DRLToMetaTransformer = {
     return {
       name: "parsed",
       imports: parseImports(clean),
+      globals: parseGlobals(clean),
       rules: extractRuleBlocks(clean).map((block) => DRLToMetaTransformer.parseRule(block))
     };
   },
@@ -821,112 +950,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);
-  }
-};
 export {
   AccumulateBuilder,
   Aggregate,