@criterionx/generators 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,211 @@
+import { Decision } from '@criterionx/core';
+
+/**
+ * Types for decision specification format
+ */
+/**
+ * Schema field type specification
+ */
+type SchemaFieldType = "string" | "number" | "boolean" | "date" | "array" | "object";
+/**
+ * Schema field definition
+ */
+interface SchemaField {
+    /** Field type */
+    type: SchemaFieldType;
+    /** Whether field is optional */
+    optional?: boolean;
+    /** Description for documentation */
+    description?: string;
+    /** For arrays: item type */
+    items?: SchemaFieldType | SchemaSpec;
+    /** For objects: nested schema */
+    properties?: Record<string, SchemaField>;
+    /** Enum values for string fields */
+    enum?: string[];
+    /** Minimum value for numbers */
+    min?: number;
+    /** Maximum value for numbers */
+    max?: number;
+    /** Default value */
+    default?: unknown;
+}
+/**
+ * Schema specification
+ */
+type SchemaSpec = Record<string, SchemaField>;
+/**
+ * Rule condition specification
+ */
+interface RuleCondition {
+    /** Field path (e.g., "input.value", "profile.threshold") */
+    field: string;
+    /** Comparison operator */
+    operator: "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "contains" | "matches";
+    /** Value to compare against (can reference other fields with $) */
+    value: unknown;
+}
+/**
+ * Rule specification
+ */
+interface RuleSpec {
+    /** Unique rule ID */
+    id: string;
+    /** Human-readable description */
+    description?: string;
+    /** Conditions (all must match - AND logic) */
+    when: RuleCondition[] | "always";
+    /** Output to emit when rule matches */
+    emit: Record<string, unknown>;
+    /** Priority (lower runs first, default: 0) */
+    priority?: number;
+}
+/**
+ * Decision specification
+ */
+interface DecisionSpec {
+    /** Unique decision ID */
+    id: string;
+    /** Version string */
+    version: string;
+    /** Human-readable description */
+    description?: string;
+    /** Input schema */
+    input: SchemaSpec;
+    /** Output schema */
+    output: SchemaSpec;
+    /** Profile schema */
+    profile: SchemaSpec;
+    /** Rules (evaluated in order) */
+    rules: RuleSpec[];
+}
+/**
+ * Options for code generation
+ */
+interface CodeGenOptions {
+    /** Include JSDoc comments */
+    includeComments?: boolean;
+    /** Use const assertions */
+    useConst?: boolean;
+    /** Export name for the decision */
+    exportName?: string;
+    /** Include zod import */
+    includeImports?: boolean;
+}
+/**
+ * Generated code result
+ */
+interface GeneratedCode {
+    /** Generated TypeScript code */
+    code: string;
+    /** Decision ID */
+    decisionId: string;
+    /** Export name used */
+    exportName: string;
+}
+
+/**
+ * Parse decision specifications into runtime decisions
+ *
+ * @example
+ * ```typescript
+ * import { parseDecisionSpec } from "@criterionx/generators";
+ *
+ * const spec = {
+ *   id: "pricing",
+ *   version: "1.0.0",
+ *   input: { quantity: { type: "number" } },
+ *   output: { price: { type: "number" } },
+ *   profile: { basePrice: { type: "number" } },
+ *   rules: [
+ *     {
+ *       id: "calculate",
+ *       when: "always",
+ *       emit: { price: "$input.quantity * $profile.basePrice" },
+ *     },
+ *   ],
+ * };
+ *
+ * const decision = parseDecisionSpec(spec);
+ * ```
+ */
+
+/**
+ * Parse a decision specification into a runtime Decision
+ *
+ * @example
+ * ```typescript
+ * const spec: DecisionSpec = {
+ *   id: "eligibility",
+ *   version: "1.0.0",
+ *   input: { age: { type: "number" } },
+ *   output: { eligible: { type: "boolean" }, reason: { type: "string" } },
+ *   profile: { minAge: { type: "number" } },
+ *   rules: [
+ *     {
+ *       id: "too-young",
+ *       when: [{ field: "input.age", operator: "lt", value: "$profile.minAge" }],
+ *       emit: { eligible: false, reason: "Too young" },
+ *     },
+ *     {
+ *       id: "eligible",
+ *       when: "always",
+ *       emit: { eligible: true, reason: "Meets requirements" },
+ *     },
+ *   ],
+ * };
+ *
+ * const decision = parseDecisionSpec(spec);
+ * const result = engine.run(decision, { age: 25 }, { profile: { minAge: 18 } });
+ * ```
+ */
+declare function parseDecisionSpec<TInput, TOutput, TProfile>(spec: DecisionSpec): Decision<TInput, TOutput, TProfile>;
+/**
+ * Parse multiple decision specifications
+ */
+declare function parseDecisionSpecs(specs: DecisionSpec[]): Map<string, Decision<any, any, any>>;
+
+/**
+ * Generate TypeScript code from decision specifications
+ *
+ * @example
+ * ```typescript
+ * import { generateDecisionCode } from "@criterionx/generators";
+ *
+ * const spec = {
+ *   id: "pricing",
+ *   version: "1.0.0",
+ *   input: { quantity: { type: "number" } },
+ *   output: { price: { type: "number" } },
+ *   profile: { basePrice: { type: "number" } },
+ *   rules: [
+ *     { id: "calculate", when: "always", emit: { price: 0 } },
+ *   ],
+ * };
+ *
+ * const { code } = generateDecisionCode(spec);
+ * // Outputs TypeScript code defining the decision
+ * ```
+ */
+
+/**
+ * Generate TypeScript code for a decision specification
+ *
+ * @example
+ * ```typescript
+ * const { code } = generateDecisionCode(spec, {
+ *   includeComments: true,
+ *   includeImports: true,
+ * });
+ *
+ * // Write to file
+ * fs.writeFileSync("pricing.decision.ts", code);
+ * ```
+ */
+declare function generateDecisionCode(spec: DecisionSpec, options?: CodeGenOptions): GeneratedCode;
+/**
+ * Generate TypeScript code for multiple decisions in a single file
+ */
+declare function generateDecisionsFile(specs: DecisionSpec[], options?: CodeGenOptions): string;
+
+export { type CodeGenOptions, type DecisionSpec, type GeneratedCode, type RuleCondition, type RuleSpec, type SchemaField, type SchemaFieldType, type SchemaSpec, generateDecisionCode, generateDecisionsFile, parseDecisionSpec, parseDecisionSpecs };