@nice-code/action 0.0.19 → 0.0.21

package/build/index.js

@@ -1,3 +1,35 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
 // src/ActionRequestResponse/ActionRequester/NiceActionRequester.ts
 class NiceActionRequester {
   cases = [];
@@ -422,6 +454,7 @@ class NiceError extends Error {
   ids;
   wasntNice;
   httpStatusCode;
+  timeCreated;
   originError;
   _packedState;
   _errorDataMap;
@@ -435,6 +468,7 @@ class NiceError extends Error {
     if (options.originError != null) {
       this.originError = options.originError;
     }
+    this.timeCreated = options.timeCreated ?? Date.now();
   }
   hasId(id) {
     return id in this._errorDataMap;
@@ -512,7 +546,12 @@ class NiceError extends Error {
       } else {
         contextState = data.contextState;
       }
-      errorData[id] = { contextState, message: data.message, httpStatusCode: data.httpStatusCode };
+      errorData[id] = {
+        contextState,
+        message: data.message,
+        httpStatusCode: data.httpStatusCode,
+        timeAdded: data.timeAdded
+      };
     }
     return {
       name: "NiceError",
@@ -522,34 +561,49 @@ class NiceError extends Error {
       wasntNice: this.wasntNice,
       message: this.message,
       httpStatusCode: this.httpStatusCode,
+      timeCreated: this.timeCreated,
       ...this.stack != null ? { stack: this.stack } : {},
       originError
     };
   }
+  toJsonString() {
+    return JSON.stringify(this.toJsonObject());
+  }
+  toHttpResponse() {
+    return new Response(this.toJsonString(), {
+      status: this.httpStatusCode,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
   hydrate(definedNiceError) {
     return definedNiceError.hydrate(this);
   }
-  handleWith(cases) {
-    for (const c of cases) {
-      if (!c._domain.isExact(this))
-        continue;
-      if (c._ids != null && !this.hasOneOfIds(c._ids))
-        continue;
-      c._handler(c._domain.hydrate(this));
-      return true;
+  handleWithSync(handlerInput, handlerOptions = {}) {
+    const handlersArray = Array.isArray(handlerInput) ? handlerInput : [handlerInput];
+    for (const handler of handlersArray) {
+      const result = handler.handleErrorWithPromiseInspection(this, handlerOptions);
+      if (result.matched) {
+        if (result.isPromise) {
+          console.warn(`[NiceError.handleWith] Handler ${result.target.identifier} returned a Promise but was called via \`handleWith\` (synchronous). ` + `The Promise will not be awaited. Use \`handleWithAsync\` for async handlers.`);
+        }
+        return result.isPromise ? undefined : result.handlerResponse;
+      }
     }
-    return false;
+    if (handlerOptions.throwOnUnhandled === true)
+      throw this;
+    return;
   }
-  async handleWithAsync(cases) {
-    for (const c of cases) {
-      if (!c._domain.isExact(this))
-        continue;
-      if (c._ids != null && !this.hasOneOfIds(c._ids))
-        continue;
-      await c._handler(c._domain.hydrate(this));
-      return true;
+  async handleWithAsync(handlerInput, handlerOptions = {}) {
+    const handlersArray = Array.isArray(handlerInput) ? handlerInput : [handlerInput];
+    for (const handler of handlersArray) {
+      const result = handler.handleErrorWithPromiseInspection(this, handlerOptions);
+      if (result.matched) {
+        return result.isPromise ? await result.handlerPromise : result.handlerResponse;
+      }
     }
-    return false;
+    if (handlerOptions.throwOnUnhandled === true)
+      throw this;
+    return;
   }
   get isPacked() {
     return this._packedState != null;
@@ -629,7 +683,7 @@ class NiceErrorHydrated extends NiceError {
 }
 
 // ../nice-error/src/NiceErrorDefined/NiceErrorDefined.ts
-class NiceErrorDefined {
+class NiceErrorDomain {
   domain;
   allDomains;
   defaultHttpStatusCode;
@@ -654,7 +708,7 @@ class NiceErrorDefined {
     }
   }
   createChildDomain(subErrorDef) {
-    const child = new NiceErrorDefined({
+    const child = new NiceErrorDomain({
       domain: subErrorDef.domain,
       allDomains: [subErrorDef.domain, ...this.allDomains],
       schema: subErrorDef.schema,
@@ -710,9 +764,10 @@ class NiceErrorDefined {
     if (errDef.domain !== this.domain) {
       throw new Error(`[NiceErrorDefined.hydrate] Domain mismatch: this definition is "${this.domain}" ` + `but the error belongs to "${errDef.domain}". ` + `Call \`niceErrorDefined.is(error)\` before hydrating to ensure compatibility.`);
     }
+    const finalError = error instanceof NiceError ? error : new NiceError(error);
     const reconciledErrorData = {};
-    for (const id of error.getIds()) {
-      const existingData = error.getErrorDataForId(id);
+    for (const id of finalError.getIds()) {
+      const existingData = finalError.getErrorDataForId(id);
       if (existingData == null)
         continue;
       let contextState = existingData.contextState;
@@ -730,18 +785,20 @@ class NiceErrorDefined {
       reconciledErrorData[id] = {
         contextState,
         message: existingData.message,
-        httpStatusCode: existingData.httpStatusCode
+        httpStatusCode: existingData.httpStatusCode,
+        timeAdded: existingData.timeAdded
       };
     }
     return new NiceErrorHydrated({
       def: this._buildDef(),
       niceErrorDefined: this,
-      ids: error.ids,
+      ids: finalError.ids,
       errorData: reconciledErrorData,
-      message: error.message,
-      httpStatusCode: error.httpStatusCode,
-      wasntNice: error.wasntNice,
-      originError: error.originError
+      message: finalError.message,
+      httpStatusCode: finalError.httpStatusCode,
+      wasntNice: finalError.wasntNice,
+      originError: finalError.originError,
+      timeCreated: finalError.timeCreated
     });
   }
   fromId(...args) {
@@ -832,13 +889,13 @@ class NiceErrorDefined {
     } else {
       contextState = { kind: "serde_unset" /* serde_unset */, value: context };
     }
-    return { contextState, message, httpStatusCode };
+    return { contextState, message, httpStatusCode, timeAdded: Date.now() };
   }
 }
 
 // ../nice-error/src/NiceErrorDefined/defineNiceError.ts
 var defineNiceError = (definition) => {
-  return new NiceErrorDefined({
+  return new NiceErrorDomain({
     domain: definition.domain,
     allDomains: [definition.domain],
     schema: definition.schema,
@@ -906,6 +963,10 @@ var err_cast_not_nice = err_nice.createChildDomain({
     })
   }
 });
+var err_nice_handler = err_nice.createChildDomain({
+  domain: "err_nice_handler",
+  schema: {}
+});
 // ../nice-error/src/utils/isNiceErrorObject.ts
 function isNiceErrorObject(obj) {
   if (typeof obj !== "object" || obj == null)
@@ -3208,6 +3269,12 @@ class NiceActionResponse {
   toJsonString() {
     return JSON.stringify(this.toJsonObject());
   }
+  toHttpResponse() {
+    return new Response(this.toJsonString(), {
+      status: 200,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
 }
 function hydrateNiceActionResponse(wire, coreAction) {
   const rawInput = coreAction.schema.deserializeInput(wire.input);
@@ -3247,6 +3314,12 @@ class NiceActionPrimed {
   toJsonString() {
     return JSON.stringify(this.toJsonObject());
   }
+  toHttpResponse() {
+    return new Response(this.toJsonString(), {
+      status: 200,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
   setOutput(output) {
     return new NiceActionResponse(this, { ok: true, output });
   }
@@ -3300,6 +3373,15 @@ class NiceAction {
       cuid: this.cuid
     };
   }
+  toJsonString() {
+    return JSON.stringify(this.toJsonObject());
+  }
+  toHttpResponse() {
+    return new Response(this.toJsonString(), {
+      status: 200,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
   toValidationSchema() {
     return object({
       domain: literal(this.domain),
@@ -3386,41 +3468,43 @@ class NiceActionDomain {
   }
   async _dispatchAction(primed, envId) {
     if (envId != null) {
-      const requester = this._requesters.get(envId);
-      if (requester) {
+      const envRequester = this._requesters.get(envId);
+      if (envRequester) {
         const validatedPrimed = await this._withValidatedInput(primed);
-        const result = await requester.handleAction(validatedPrimed);
+        const result = await envRequester.handleAction(validatedPrimed);
         for (const listener of this._listeners)
           await listener(validatedPrimed);
         return result;
       }
-      const responder = this._responders.get(envId);
-      if (responder) {
-        const result = await responder._resolvePrimed(primed);
+      const envResponder = this._responders.get(envId);
+      if (envResponder) {
+        const result = await envResponder._resolvePrimed(primed);
         for (const listener of this._listeners)
           await listener(primed);
         return result;
       }
-      throw err_nice_action.fromId("action_environment_not_found" /* action_environment_not_found */, {
-        domain: this.domain,
-        envId
-      });
     }
-    const defaultHandler = this._requesters.get(undefined);
-    if (defaultHandler) {
+    const defaultRequester = this._requesters.get(undefined);
+    if (defaultRequester) {
       const validatedPrimed = await this._withValidatedInput(primed);
-      const result = await defaultHandler.handleAction(validatedPrimed);
+      const result = await defaultRequester.handleAction(validatedPrimed);
       for (const listener of this._listeners)
         await listener(validatedPrimed);
       return result;
     }
-    const defaultResolver = this._responders.get(undefined);
-    if (defaultResolver) {
-      const result = await defaultResolver._resolvePrimed(primed);
+    const defaultResponder = this._responders.get(undefined);
+    if (defaultResponder) {
+      const result = await defaultResponder._resolvePrimed(primed);
       for (const listener of this._listeners)
         await listener(primed);
       return result;
     }
+    if (envId != null) {
+      throw err_nice_action.fromId("action_environment_not_found" /* action_environment_not_found */, {
+        domain: this.domain,
+        envId
+      });
+    }
     throw err_nice_action.fromId("domain_no_handler" /* domain_no_handler */, { domain: this.domain });
   }
   async _withValidatedInput(primed) {
@@ -3485,7 +3569,7 @@ class NiceActionDomain {
     });
     return hydrateNiceActionResponse(serialized, coreAction);
   }
-  setActionRequester(handler, options) {
+  setActionRequester(options, handler) {
     const envId = options?.envId;
     if (this._requesters.has(envId)) {
       if (envId != null) {