feat: non-static evaluate function

Author: kevinmichaelchen

README.md

@@ -27,13 +27,13 @@ There are two ways to use CEL expressions in your code:
 For simple use cases where you evaluate an expression once:
 
 ```typescript
-import { CelProgram } from "cel-typescript";
+import { evaluate } from "cel-typescript";
 
 // Basic string and numeric operations
-await CelProgram.evaluate("size(message) > 5", { message: "Hello World" }); // true
+await evaluate("size(message) > 5", { message: "Hello World" }); // true
 
 // Complex object traversal and comparison
-await CelProgram.evaluate("user.age >= 18 && user.preferences.notifications", {
+await evaluate("user.age >= 18 && user.preferences.notifications", {
   user: {
     age: 25,
     preferences: { notifications: true },

__tests__/cel.test.ts

@@ -138,9 +138,7 @@ describe("Performance measurements", () => {
     console.log(`Execution took ${executeTime.toFixed(0)} nanoseconds`);
 
     // Measure one-step evaluation time
-    const [, evaluateTime] = await measureTime(() =>
-      CelProgram.evaluate(expr, context),
-    );
+    const [, evaluateTime] = await measureTime(() => evaluate(expr, context));
     console.log(
       `One-step evaluation took ${evaluateTime.toFixed(0)} nanoseconds`,
     );
@@ -159,44 +157,3 @@ describe("Performance measurements", () => {
     expect(evaluateTime).toBeLessThan(expectedEvaluateTime * (1 + tolerance));
   });
 });
-
-describe("CelProgram.evaluate", () => {
-  it("should evaluate a simple expression in one step", async () => {
-    const result = await CelProgram.evaluate("size(message) > 5", {
-      message: "Hello World",
-    });
-    expect(result).toBe(true);
-  });
-
-  it("should handle errors gracefully", async () => {
-    await expect(
-      CelProgram.evaluate("invalid expression", {}),
-    ).rejects.toThrow();
-  });
-
-  it("should handle complex expressions and data structures", async () => {
-    const result = await CelProgram.evaluate(
-      '{"name": "test", "items": [1, 2, 3].map(i, {"id": i})}',
-      {},
-    );
-    expect(result).toEqual({
-      name: "test",
-      items: [{ id: 1 }, { id: 2 }, { id: 3 }],
-    });
-  });
-
-  it("should handle cart validation in one step", async () => {
-    const expr =
-      'has(cart.items) && cart.items.exists(item, item.productId == "prod_123" && item.quantity >= 1)';
-    const result = await CelProgram.evaluate(expr, {
-      cart: {
-        items: [
-          { productId: "prod_456", quantity: 1 },
-          { productId: "prod_123", quantity: 1 },
-          { productId: "prod_789", quantity: 3 },
-        ],
-      },
-    });
-    expect(result).toBe(true);
-  });
-});

src/index.ts

@@ -44,16 +44,6 @@ class CelProgram {
   async execute(context: CelContext): Promise<any> {
     return this.native.execute(context);
   }
-
-  /**
-   * Convenience method to compile and execute a CEL expression in one step.
-   * Note: If you plan to evaluate the same expression multiple times with different contexts,
-   * it's more efficient to use compile() once and then call execute() multiple times.
-   */
-  static async evaluate(source: string, context: CelContext): Promise<any> {
-    const program = await CelProgram.compile(source);
-    return program.execute(context);
-  }
 }
 
 /**
@@ -66,7 +56,8 @@ class CelProgram {
  * @returns The result of evaluating the expression
  */
 async function evaluate(source: string, context: CelContext): Promise<any> {
-  return CelProgram.evaluate(source, context);
+  const program = await CelProgram.compile(source);
+  return program.execute(context);
 }
 
 export { CelProgram, evaluate };