@reactionary/core 0.2.9 → 0.2.11

package/decorators/reactionary.decorator.js

@@ -1,14 +1,11 @@
-import { trace } from "@opentelemetry/api";
+import { SpanStatusCode, 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";
 const TRACER_VERSION = "0.0.1";
-let globalTracer = null;
 function getTracer() {
-  if (!globalTracer) {
-    globalTracer = trace.getTracer(TRACER_NAME, TRACER_VERSION);
-  }
-  return globalTracer;
+  return trace.getTracer(TRACER_NAME, TRACER_VERSION);
 }
 class ReactionaryDecoratorOptions {
   constructor() {
@@ -33,6 +30,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 +66,45 @@ 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;
+          return validatedResult;
         } catch (err) {
-          console.error(err);
           status = "error";
+          trace.getActiveSpan()?.setStatus({ code: SpanStatusCode.ERROR, message: errorToString(err) });
           const result = error({
             type: "Generic",
-            message: "REDACTED"
+            message: errorToString(err)
           });
           return result;
         } finally {
@@ -159,9 +172,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.11",
   "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;

package/src/schemas/result.d.ts

@@ -19,7 +19,9 @@ export type Fail<E> = {
         trace: string;
     };
 };
-export type Result<T, E = Error> = Ok<T> | Fail<E>;
+export type Result<T, E = {
+    type: string;
+}> = Ok<T> | Fail<E>;
 /**
  * Utility function for asserting and unwrapping the value of a success.
  * It is an assert, so treat it as such (similar to any unwrap, assert or similar function).