@criterionx/trpc 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/index.d.ts

@@ -0,0 +1,152 @@
+import { Decision, Engine, ProfileRegistry, Result } from '@criterionx/core';
+
+/**
+ * Options for creating a decision procedure
+ */
+interface DecisionProcedureOptions<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>;
+    /** Default profile to use if not specified in input */
+    defaultProfile?: TProfile | string;
+}
+/**
+ * Input for decision evaluation via tRPC
+ */
+interface DecisionInput<TInput, TProfile> {
+    /** Decision input data */
+    input: TInput;
+    /** Profile object or profile ID */
+    profile?: TProfile | string;
+}
+/**
+ * Options for creating a decision router
+ */
+interface DecisionRouterOptions<TProfile> {
+    /** Decisions to include in the router */
+    decisions: Array<Decision<any, any, TProfile>>;
+    /** Profile map by decision ID or profile name */
+    profiles?: Record<string, TProfile>;
+    /** Engine instance */
+    engine?: Engine;
+    /** Profile registry */
+    registry?: ProfileRegistry<TProfile>;
+}
+/**
+ * Result type for decision evaluation
+ */
+type DecisionResult<TOutput> = Result<TOutput>;
+
+/**
+ * tRPC integration for Criterion decision engine
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { initTRPC } from "@trpc/server";
+ * import { createDecisionProcedure } from "@criterionx/trpc";
+ * import { pricingDecision } from "./decisions";
+ *
+ * const t = initTRPC.create();
+ *
+ * const appRouter = t.router({
+ *   pricing: createDecisionProcedure(t, {
+ *     decision: pricingDecision,
+ *     defaultProfile: { basePrice: 100 },
+ *   }),
+ * });
+ *
+ * // Client usage (fully typed)
+ * const result = await trpc.pricing.mutate({
+ *   input: { quantity: 5 },
+ * });
+ * ```
+ */
+
+/**
+ * Create a tRPC procedure for evaluating a decision
+ *
+ * Returns a mutation procedure that accepts decision input and optional profile,
+ * and returns the evaluation result with full type inference.
+ *
+ * @example
+ * ```typescript
+ * import { initTRPC } from "@trpc/server";
+ * import { createDecisionProcedure } from "@criterionx/trpc";
+ *
+ * const t = initTRPC.create();
+ *
+ * const router = t.router({
+ *   pricing: createDecisionProcedure(t, {
+ *     decision: pricingDecision,
+ *     defaultProfile: { basePrice: 100 },
+ *   }),
+ *   eligibility: createDecisionProcedure(t, {
+ *     decision: eligibilityDecision,
+ *     defaultProfile: "standard",
+ *   }),
+ * });
+ * ```
+ */
+declare function createDecisionProcedure<TInput, TOutput, TProfile, T extends {
+    procedure: any;
+    router: any;
+}>(t: T, options: DecisionProcedureOptions<TInput, TOutput, TProfile>): ReturnType<T["procedure"]["input"]>;
+/**
+ * Create a tRPC router with procedures for multiple decisions
+ *
+ * Each decision becomes a procedure in the router, accessible by its ID.
+ *
+ * @example
+ * ```typescript
+ * import { initTRPC } from "@trpc/server";
+ * import { createDecisionRouter } from "@criterionx/trpc";
+ *
+ * const t = initTRPC.create();
+ *
+ * const decisionsRouter = createDecisionRouter(t, {
+ *   decisions: [pricingDecision, eligibilityDecision],
+ *   profiles: {
+ *     pricing: { basePrice: 100 },
+ *     eligibility: { minAge: 18 },
+ *   },
+ * });
+ *
+ * const appRouter = t.router({
+ *   decisions: decisionsRouter,
+ * });
+ *
+ * // Client usage
+ * const result = await trpc.decisions.pricing.mutate({ input: { quantity: 5 } });
+ * ```
+ */
+declare function createDecisionRouter<TProfile, T extends {
+    procedure: any;
+    router: any;
+}>(t: T, options: DecisionRouterOptions<TProfile>): ReturnType<T["router"]>;
+/**
+ * Helper to create a typed decision caller for use outside of tRPC context
+ *
+ * Useful for server-side code that needs to call decisions directly
+ * with the same interface as tRPC procedures.
+ *
+ * @example
+ * ```typescript
+ * import { createDecisionCaller } from "@criterionx/trpc";
+ *
+ * const callPricing = createDecisionCaller({
+ *   decision: pricingDecision,
+ *   defaultProfile: { basePrice: 100 },
+ * });
+ *
+ * const result = callPricing({ input: { quantity: 5 } });
+ * ```
+ */
+declare function createDecisionCaller<TInput, TOutput, TProfile>(options: DecisionProcedureOptions<TInput, TOutput, TProfile>): (args: {
+    input: TInput;
+    profile?: TProfile | string;
+}) => Result<TOutput>;
+
+export { type DecisionInput, type DecisionProcedureOptions, type DecisionResult, type DecisionRouterOptions, createDecisionCaller, createDecisionProcedure, createDecisionRouter };