@reactionary/core 0.2.9 → 0.2.10

package/decorators/reactionary.decorator.js

@@ -1,4 +1,5 @@
 import { trace } from "@opentelemetry/api";
+import { z } from "zod";
 import { getReactionaryMeter } from "../metrics/metrics.js";
 import { error, success } from "../schemas/result.js";
 const TRACER_NAME = "@reactionary";
@@ -33,6 +34,14 @@ class ReactionaryDecoratorOptions {
      * given query.
      */
     this.cacheTimeToLiveInSeconds = 60;
+    /**
+     * The schema for the input (query or mutation) type, for validation purposes
+     */
+    this.inputSchema = z.never();
+    /**
+     * The schema for the primary output type, for validation purposes
+     */
+    this.outputSchema = z.never();
   }
 }
 function Reactionary(options) {
@@ -61,37 +70,44 @@ function Reactionary(options) {
             return input;
           }
           const cacheKey = this.generateCacheKeyForQuery(scope, input.value);
-          const fromCache = await this.cache.get(
-            cacheKey,
-            options.inputSchema
-          );
+          let fromCache = null;
+          if (options.cache) {
+            fromCache = await this.cache.get(
+              cacheKey,
+              options.outputSchema
+            );
+          }
           let result;
           if (!fromCache) {
             result = await original.apply(this, [input.value]);
             const r = result;
             if (r.success) {
               const dependencyIds = this.generateDependencyIdsForModel(r.value);
-              this.cache.put(cacheKey, r.value, {
-                ttlSeconds: configuration.cacheTimeToLiveInSeconds,
-                dependencyIds
-              });
+              if (options.cache) {
+                this.cache.put(cacheKey, r.value, {
+                  ttlSeconds: configuration.cacheTimeToLiveInSeconds,
+                  dependencyIds
+                });
+              }
             }
           } else {
             result = success(fromCache);
             cacheStatus = "hit";
           }
-          const validatedResult = validateOutput(result, configuration.outputSchema);
+          const validatedResult = validateOutput(
+            result,
+            configuration.outputSchema
+          );
           if (validatedResult.success) {
             validatedResult.meta.cache.hit = !!fromCache;
             validatedResult.meta.cache.key = cacheKey;
           }
           return result;
         } catch (err) {
-          console.error(err);
           status = "error";
           const result = error({
             type: "Generic",
-            message: "REDACTED"
+            message: errorToString(err)
           });
           return result;
         } finally {
@@ -159,9 +175,23 @@ async function traceSpan(name, fn) {
     }
   });
 }
+function errorToString(err) {
+  if (err instanceof Error) {
+    return err.stack ?? err.message;
+  }
+  if (typeof err === "string") {
+    return err;
+  }
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
 export {
   Reactionary,
   ReactionaryDecoratorOptions,
+  errorToString,
   getTracer,
   traceSpan,
   validateInput,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactionary/core",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {

package/src/decorators/reactionary.decorator.d.ts

@@ -1,5 +1,5 @@
 import type { Tracer } from '@opentelemetry/api';
-import type { z } from 'zod';
+import { z } from 'zod';
 import type { BaseProvider } from '../providers/index.js';
 import { type Result } from '../schemas/result.js';
 export declare function getTracer(): Tracer;
@@ -32,11 +32,11 @@ export declare class ReactionaryDecoratorOptions {
     /**
      * The schema for the input (query or mutation) type, for validation purposes
      */
-    inputSchema?: z.ZodType;
+    inputSchema: z.ZodType;
     /**
      * The schema for the primary output type, for validation purposes
      */
-    outputSchema?: z.ZodType;
+    outputSchema: z.ZodType;
 }
 /**
  * Decorator for provider functions to provide functionality such as caching, tracing and type-checked
@@ -57,3 +57,8 @@ export declare function validateOutput(output: Result<unknown>, schema: z.ZodTyp
  * traced span for OTEL handling.
  */
 export declare function traceSpan<T>(name: string, fn: () => Promise<T> | T): Promise<T>;
+/**
+ * Utility function for converting a caught error to a plain
+ * string for reporting back.
+ */
+export declare function errorToString(err: unknown): string;