@criterionx/express 0.3.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Tomas Maritano
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunk-3RG5ZIWI.js

@@ -0,0 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};

package/dist/chunk-Y5OYMKPU.js

@@ -0,0 +1,139 @@
+// src/fastify.ts
+import { Engine } from "@criterionx/core";
+var defaultEngine = new Engine();
+var criterionPlugin = async (fastify, options) => {
+  const {
+    decisions,
+    profiles = {},
+    engine = defaultEngine,
+    registry,
+    prefix = "/decisions"
+  } = options;
+  for (const decision of decisions) {
+    fastify.post(`${prefix}/${decision.id}`, async (request, reply) => {
+      try {
+        const body = request.body;
+        const query = request.query;
+        const input = body;
+        const profileKey = query?.profile ?? body?.profile;
+        const profile = profileKey && profiles[profileKey] ? profiles[profileKey] : profileKey ?? profiles[decision.id];
+        const result = engine.run(decision, input, { profile }, registry);
+        request.criterion = {
+          result,
+          decision: decision.id,
+          evaluatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        if (result.status !== "OK") {
+          reply.status(400);
+          return {
+            error: {
+              code: result.status,
+              message: result.meta.explanation
+            },
+            result,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        }
+        return result;
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        reply.status(400);
+        return {
+          error: {
+            code: "EVALUATION_ERROR",
+            message: err.message
+          },
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+    });
+  }
+};
+function createDecisionRoute(options) {
+  const {
+    decision,
+    engine = defaultEngine,
+    registry,
+    getInput = (request) => request.body,
+    getProfile = (request) => {
+      const query = request.query;
+      const body = request.body;
+      return query?.profile ?? body?.profile;
+    },
+    formatResponse = (result) => result
+  } = options;
+  return async (request, reply) => {
+    try {
+      const input = getInput(request);
+      const profile = getProfile(request);
+      const result = engine.run(decision, input, { profile }, registry);
+      request.criterion = {
+        result,
+        decision: decision.id,
+        evaluatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (result.status !== "OK") {
+        reply.status(400);
+        return {
+          error: {
+            code: result.status,
+            message: result.meta.explanation
+          },
+          result: formatResponse(result),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      return formatResponse(result);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      reply.status(400);
+      return {
+        error: {
+          code: "EVALUATION_ERROR",
+          message: err.message
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+  };
+}
+function createDecisionHook(options) {
+  const {
+    decision,
+    engine = defaultEngine,
+    registry,
+    getInput = (request) => request.body,
+    getProfile = (request) => {
+      const query = request.query;
+      const body = request.body;
+      return query?.profile ?? body?.profile;
+    }
+  } = options;
+  return async (request, reply) => {
+    try {
+      const input = getInput(request);
+      const profile = getProfile(request);
+      const result = engine.run(decision, input, { profile }, registry);
+      request.criterion = {
+        result,
+        decision: decision.id,
+        evaluatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      reply.status(400).send({
+        error: {
+          code: "EVALUATION_ERROR",
+          message: err.message
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  };
+}
+
+export {
+  criterionPlugin,
+  createDecisionRoute,
+  createDecisionHook
+};

package/dist/chunk-YSMNRLEG.js

@@ -0,0 +1,117 @@
+import {
+  __require
+} from "./chunk-3RG5ZIWI.js";
+
+// src/express.ts
+import { Engine } from "@criterionx/core";
+var defaultEngine = new Engine();
+function createDecisionMiddleware(options) {
+  const {
+    decision,
+    engine = defaultEngine,
+    registry,
+    getInput = (req) => req.body,
+    getProfile = (req) => {
+      const r = req;
+      return r.query?.profile ?? r.body?.profile;
+    },
+    formatResponse = (result) => result,
+    onError
+  } = options;
+  return (req, res, _next) => {
+    try {
+      const input = getInput(req);
+      const profile = getProfile(req);
+      const result = engine.run(decision, input, { profile }, registry);
+      req.criterion = {
+        result,
+        decision: decision.id,
+        evaluatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (result.status !== "OK") {
+        res.status(400).json({
+          error: {
+            code: result.status,
+            message: result.meta.explanation
+          },
+          result: formatResponse(result),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return;
+      }
+      res.json(formatResponse(result));
+    } catch (error) {
+      if (onError) {
+        onError(error instanceof Error ? error : new Error(String(error)), req, res);
+        return;
+      }
+      const err = error instanceof Error ? error : new Error(String(error));
+      res.status(400).json({
+        error: {
+          code: "EVALUATION_ERROR",
+          message: err.message
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  };
+}
+function createDecisionHandler(options) {
+  const {
+    decision,
+    engine = defaultEngine,
+    registry,
+    getInput = (req) => req.body,
+    getProfile = (req) => {
+      const r = req;
+      return r.query?.profile ?? r.body?.profile;
+    },
+    onError
+  } = options;
+  return (req, res, next) => {
+    try {
+      const input = getInput(req);
+      const profile = getProfile(req);
+      const result = engine.run(decision, input, { profile }, registry);
+      req.criterion = {
+        result,
+        decision: decision.id,
+        evaluatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      next();
+    } catch (error) {
+      if (onError) {
+        onError(error instanceof Error ? error : new Error(String(error)), req, res);
+        return;
+      }
+      next(error);
+    }
+  };
+}
+function createDecisionRouter(options) {
+  const { Router } = __require("express");
+  const router = Router();
+  const { decisions, profiles = {}, engine = defaultEngine, registry } = options;
+  for (const decision of decisions) {
+    router.post(`/${decision.id}`, createDecisionMiddleware({
+      decision,
+      engine,
+      registry,
+      getProfile: (req) => {
+        const r = req;
+        const profileKey = r.query?.profile ?? r.body?.profile;
+        if (typeof profileKey === "string" && profiles[profileKey]) {
+          return profiles[profileKey];
+        }
+        return profileKey ?? profiles[decision.id];
+      }
+    }));
+  }
+  return router;
+}
+
+export {
+  createDecisionMiddleware,
+  createDecisionHandler,
+  createDecisionRouter
+};

package/dist/express.d.ts

@@ -0,0 +1,81 @@
+import * as express from 'express';
+import { RequestHandler } from 'express';
+import * as _criterionx_core from '@criterionx/core';
+import { Engine } from '@criterionx/core';
+import { C as CriterionResult, D as DecisionMiddlewareOptions } from './types-Dz8OTTmP.js';
+
+declare global {
+    namespace Express {
+        interface Request {
+            criterion?: CriterionResult<any>;
+        }
+    }
+}
+/**
+ * Create Express middleware that evaluates a decision and sends the result
+ *
+ * The middleware extracts input from the request, evaluates the decision,
+ * and sends the result as JSON response.
+ *
+ * @example With custom input extraction
+ * ```typescript
+ * app.post("/evaluate/:decisionId", createDecisionMiddleware({
+ *   decision: myDecision,
+ *   getInput: (req) => ({
+ *     ...req.body,
+ *     userId: req.params.userId,
+ *   }),
+ *   getProfile: (req) => req.query.profile as string,
+ * }));
+ * ```
+ */
+declare function createDecisionMiddleware<TInput, TOutput, TProfile>(options: DecisionMiddlewareOptions<TInput, TOutput, TProfile>): RequestHandler;
+/**
+ * Create Express middleware that evaluates a decision and attaches result to request
+ *
+ * Unlike createDecisionMiddleware, this middleware calls next() instead of
+ * sending a response, allowing downstream middleware to access the result.
+ *
+ * @example
+ * ```typescript
+ * app.post("/pricing",
+ *   createDecisionHandler({
+ *     decision: pricingDecision,
+ *     getProfile: () => ({ basePrice: 100 }),
+ *   }),
+ *   (req, res) => {
+ *     const { result } = req.criterion!;
+ *     res.json({ price: result.data?.price, meta: { custom: true } });
+ *   }
+ * );
+ * ```
+ */
+declare function createDecisionHandler<TInput, TOutput, TProfile>(options: DecisionMiddlewareOptions<TInput, TOutput, TProfile>): RequestHandler;
+/**
+ * Create an Express router with decision endpoints
+ *
+ * @example
+ * ```typescript
+ * import { createDecisionRouter } from "@criterionx/express/express";
+ *
+ * const router = createDecisionRouter({
+ *   decisions: [pricingDecision, eligibilityDecision],
+ *   profiles: {
+ *     "pricing": { basePrice: 100 },
+ *     "eligibility": { minAge: 18 },
+ *   },
+ * });
+ *
+ * app.use("/decisions", router);
+ * // POST /decisions/pricing
+ * // POST /decisions/eligibility
+ * ```
+ */
+declare function createDecisionRouter<TProfile>(options: {
+    decisions: Array<_criterionx_core.Decision<any, any, TProfile>>;
+    profiles?: Record<string, TProfile>;
+    engine?: Engine;
+    registry?: _criterionx_core.ProfileRegistry<TProfile>;
+}): express.Router;
+
+export { createDecisionHandler, createDecisionMiddleware, createDecisionRouter };

package/dist/express.js

@@ -0,0 +1,11 @@
+import {
+  createDecisionHandler,
+  createDecisionMiddleware,
+  createDecisionRouter
+} from "./chunk-YSMNRLEG.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  createDecisionHandler,
+  createDecisionMiddleware,
+  createDecisionRouter
+};

package/dist/fastify.d.ts

@@ -0,0 +1,115 @@
+import { FastifyPluginAsync, FastifyRequest, RouteHandlerMethod, FastifyReply } from 'fastify';
+import { Decision, Engine, ProfileRegistry, Result } from '@criterionx/core';
+import { C as CriterionResult } from './types-Dz8OTTmP.js';
+
+/**
+ * Fastify plugin for Criterion decision engine
+ *
+ * @example Basic usage
+ * ```typescript
+ * import Fastify from "fastify";
+ * import { criterionPlugin } from "@criterionx/express/fastify";
+ * import { pricingDecision } from "./decisions";
+ *
+ * const app = Fastify();
+ *
+ * app.register(criterionPlugin, {
+ *   decisions: [pricingDecision],
+ *   profiles: { pricing: { basePrice: 100 } },
+ * });
+ *
+ * app.listen({ port: 3000 });
+ * // POST /decisions/pricing
+ * ```
+ */
+
+declare module "fastify" {
+    interface FastifyRequest {
+        criterion?: CriterionResult<any>;
+    }
+}
+/**
+ * Options for Fastify Criterion plugin
+ */
+interface CriterionPluginOptions<TProfile> {
+    /** Decisions to register */
+    decisions: Array<Decision<any, any, TProfile>>;
+    /** Profile map by decision ID */
+    profiles?: Record<string, TProfile>;
+    /** Engine instance */
+    engine?: Engine;
+    /** Profile registry */
+    registry?: ProfileRegistry<TProfile>;
+    /** Route prefix (default: "/decisions") */
+    prefix?: string;
+}
+/**
+ * Fastify plugin that registers decision endpoints
+ *
+ * @example With custom prefix
+ * ```typescript
+ * app.register(criterionPlugin, {
+ *   decisions: [pricingDecision],
+ *   profiles: { pricing: { basePrice: 100 } },
+ *   prefix: "/api/v1/evaluate",
+ * });
+ * // POST /api/v1/evaluate/pricing
+ * ```
+ */
+declare const criterionPlugin: FastifyPluginAsync<CriterionPluginOptions<unknown>>;
+/**
+ * Options for creating a decision route handler
+ */
+interface DecisionRouteOptions<TInput, TOutput, TProfile> {
+    /** The decision to evaluate */
+    decision: Decision<TInput, TOutput, TProfile>;
+    /** Engine instance */
+    engine?: Engine;
+    /** Profile registry */
+    registry?: ProfileRegistry<TProfile>;
+    /** Extract input from request */
+    getInput?: (request: FastifyRequest) => TInput;
+    /** Get profile or profile ID */
+    getProfile?: (request: FastifyRequest) => TProfile | string;
+    /** Custom response formatter */
+    formatResponse?: (result: Result<TOutput>) => unknown;
+}
+/**
+ * Create a Fastify route handler for a decision
+ *
+ * @example
+ * ```typescript
+ * import { createDecisionRoute } from "@criterionx/express/fastify";
+ *
+ * app.post("/pricing", createDecisionRoute({
+ *   decision: pricingDecision,
+ *   getProfile: () => ({ basePrice: 100 }),
+ * }));
+ * ```
+ */
+declare function createDecisionRoute<TInput, TOutput, TProfile>(options: DecisionRouteOptions<TInput, TOutput, TProfile>): RouteHandlerMethod;
+/**
+ * Fastify preHandler hook for decision evaluation
+ *
+ * Evaluates a decision and attaches the result to the request,
+ * allowing the route handler to access it.
+ *
+ * @example
+ * ```typescript
+ * import { createDecisionHook } from "@criterionx/express/fastify";
+ *
+ * app.post("/pricing", {
+ *   preHandler: createDecisionHook({
+ *     decision: pricingDecision,
+ *     getProfile: () => ({ basePrice: 100 }),
+ *   }),
+ *   handler: (request, reply) => {
+ *     const { result } = request.criterion!;
+ *     return { price: result.data?.price, meta: { custom: true } };
+ *   },
+ * });
+ * ```
+ */
+declare function createDecisionHook<TInput, TOutput, TProfile>(options: Omit<DecisionRouteOptions<TInput, TOutput, TProfile>, "formatResponse">): (request: FastifyRequest, reply: FastifyReply) => Promise<void>;
+
+export { type CriterionPluginOptions, type DecisionRouteOptions, createDecisionHook, createDecisionRoute, criterionPlugin };

package/dist/fastify.js

@@ -0,0 +1,11 @@
+import {
+  createDecisionHook,
+  createDecisionRoute,
+  criterionPlugin
+} from "./chunk-Y5OYMKPU.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  createDecisionHook,
+  createDecisionRoute,
+  criterionPlugin
+};

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { C as CriterionResult, D as DecisionMiddlewareOptions } from './types-Dz8OTTmP.js';
+export { createDecisionHandler, createDecisionMiddleware, createDecisionRouter } from './express.js';
+export { CriterionPluginOptions, DecisionRouteOptions, createDecisionHook, createDecisionRoute, criterionPlugin } from './fastify.js';
+import '@criterionx/core';
+import 'express';
+import 'fastify';

package/dist/index.js

@@ -0,0 +1,19 @@
+import {
+  createDecisionHandler,
+  createDecisionMiddleware,
+  createDecisionRouter
+} from "./chunk-YSMNRLEG.js";
+import {
+  createDecisionHook,
+  createDecisionRoute,
+  criterionPlugin
+} from "./chunk-Y5OYMKPU.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  createDecisionHandler,
+  createDecisionHook,
+  createDecisionMiddleware,
+  createDecisionRoute,
+  createDecisionRouter,
+  criterionPlugin
+};

package/dist/types-Dz8OTTmP.d.ts

@@ -0,0 +1,31 @@
+import { Result, Decision, Engine, ProfileRegistry } from '@criterionx/core';
+
+/**
+ * Options for creating decision middleware
+ */
+interface DecisionMiddlewareOptions<TInput, TOutput, TProfile> {
+    /** The decision to evaluate */
+    decision: Decision<TInput, TOutput, TProfile>;
+    /** Engine instance (uses default if not provided) */
+    engine?: Engine;
+    /** Profile registry for ID-based profile resolution */
+    registry?: ProfileRegistry<TProfile>;
+    /** Extract input from request (default: req.body) */
+    getInput?: (req: unknown) => TInput;
+    /** Get profile or profile ID (default: req.query.profile or req.body.profile) */
+    getProfile?: (req: unknown) => TProfile | string;
+    /** Custom response formatter */
+    formatResponse?: (result: Result<TOutput>) => unknown;
+    /** Custom error handler */
+    onError?: (error: Error, req: unknown, res: unknown) => void;
+}
+/**
+ * Criterion middleware result attached to request
+ */
+interface CriterionResult<TOutput> {
+    result: Result<TOutput>;
+    decision: string;
+    evaluatedAt: string;
+}
+
+export type { CriterionResult as C, DecisionMiddlewareOptions as D };

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@criterionx/express",
+  "version": "0.3.5",
+  "description": "Express and Fastify middleware for Criterion decision engine",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./express": {
+      "types": "./dist/express.d.ts",
+      "import": "./dist/express.js"
+    },
+    "./fastify": {
+      "types": "./dist/fastify.d.ts",
+      "import": "./dist/fastify.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@criterionx/core": "0.3.5"
+  },
+  "peerDependencies": {
+    "express": ">=4.0.0",
+    "fastify": ">=4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "express": {
+      "optional": true
+    },
+    "fastify": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "zod": "^3.24.0",
+    "@types/express": "^5.0.0",
+    "@types/node": "^20.0.0",
+    "@types/supertest": "^6.0.0",
+    "express": "^5.0.0",
+    "fastify": "^5.0.0",
+    "supertest": "^7.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^4.0.0"
+  },
+  "keywords": [
+    "criterion",
+    "decision",
+    "rules",
+    "express",
+    "fastify",
+    "middleware"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tomymaritano/criterionx.git",
+    "directory": "packages/express"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/express.ts src/fastify.ts --format esm --dts --clean",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}