@intrig/core 0.0.15-3 → 0.0.15-4

package/main.js

@@ -6124,7 +6124,7 @@ interface RequestType<T = any> extends AxiosRequestConfig {
   source: string
 }
 
-export type ZodOut<T> = ZodType<T, ZodTypeDef, unknown>;
+export type SchemaOf<T> = ZodType<T, ZodTypeDef, any>;
 
 /**
  * Defines the ContextType interface for managing global state, dispatching actions,
@@ -6140,7 +6140,7 @@ export interface ContextType {
   filteredState: GlobalState;
   dispatch: Dispatch<NetworkAction<unknown, unknown>>;
   configs: ${configType};
-  execute: <T>(request: RequestType, dispatch: (state: NetworkState<T>) => void, schema: ZodOut<T> | undefined, errorSchema: ZodOut<T> | undefined) => Promise<void>;
+  execute: <T>(request: RequestType, dispatch: (state: NetworkState<T>) => void, schema: SchemaOf<T> | undefined, errorSchema: SchemaOf<T> | undefined) => Promise<void>;
 }
 
 /**
@@ -6196,60 +6196,6 @@ function reactExtraTemplate(_path) {
 import { useCallback, useEffect, useId, useMemo, useRef, useState } from 'react';
 import { useIntrigContext } from '@intrig/react/intrig-context';
 
-/**
- * Converts a given hook into a promise-based function.
- *
- * @param {IntrigHook<P, B, T>} hook - The hook function to be converted.
- * @param {string} [key='default'] - An optional key to uniquely identify the hook instance.
- *
- * @return {[(...params: Parameters<ReturnType<IntrigHook<P, B, T>>[1]>) => Promise<T>, () => void]}
- * Returns a tuple containing a function that invokes the hook as a promise and a function to clear the state.
- */
-export function useAsPromise<E>(hook: UnitHook<E>, options: UnitHookOptions): [() => Promise<never>, () => void];
-export function useAsPromise<T, E>(hook: ConstantHook<T, E>, options: UnitHookOptions): [() => Promise<T>, () => void];
-export function useAsPromise<P, E>(hook: UnaryProduceHook<P, E>, options?: UnaryHookOptions<P>): [(params: P) => Promise<never>, () => void];
-export function useAsPromise<P, T, E>(  hook: UnaryFunctionHook<P, T, E>, options?: UnaryHookOptions<P>): [(params: P) => Promise<T>, () => void];
-export function useAsPromise<P, B, E>(hook: BinaryProduceHook<P, B, E>, options?: BinaryHookOptions<P, B>): [(body: B, params: P) => Promise<never>, () => void];
-export function useAsPromise<P, B, T, E>(hook: BinaryFunctionHook<P, B, T, E>, options?: BinaryHookOptions<P, B>): [(body: B, params: P) => Promise<T>, () => void];
-
-// **Implementation**
-export function useAsPromise<P, B, T, E>(
-  hook: IntrigHook<P, B, T, E>,
-  options?: IntrigHookOptions<P, B>
-): [(...args: any[]) => Promise<T>, () => void] {  // <- Compatible return type
-  const resolveRef = useRef<(value: T) => void>(() => {});
-  const rejectRef = useRef<(reason?: any) => void>(() => {});
-
-  const [state, dispatch, clear] = hook(options as any);
-
-  useEffect(() => {
-    if (isSuccess(state)) {
-      resolveRef.current?.(state.data);
-      clear();
-    } else if (isError(state)) {
-      rejectRef.current?.(state.error);
-      clear()
-    }
-  }, [state]);
-
-  const promiseFn = useCallback((...args: Parameters<ReturnType<IntrigHook<P, B, T>>[1]>) => {
-    return new Promise<T>((resolve, reject) => {
-      resolveRef.current = resolve;
-      rejectRef.current = reject;
-
-      const dispatchState = (dispatch as any)(...args);
-      if (isValidationError(dispatchState)) {
-        reject(dispatchState.error);
-      }
-    });
-  }, [dispatch]);
-
-  return [
-    promiseFn,
-    clear
-  ];
-}
-
 /**
  * A custom hook that manages and returns the network state of a promise-based function,
  * providing a way to execute the function and clear its state.
@@ -7251,7 +7197,7 @@ import logger from './logger';
 import {flushSync} from "react-dom";
 import {createParser} from "eventsource-parser";
 
-import {Context, RequestType, GlobalState, ZodOut} from './intrig-context';
+import {Context, RequestType, GlobalState, SchemaOf} from './intrig-context';
 
 /**
  * Handles state updates for network requests based on the provided action.
@@ -7554,8 +7500,8 @@ export interface NetworkStateProps<T, E = unknown> {
   key: string;
   operation: string;
   source: string;
-  schema?: ZodOut<T>;
-  errorSchema?: ZodOut<E>;
+  schema?: SchemaOf<T>;
+  errorSchema?: SchemaOf<E>;
   debounceDelay?: number;
 }
 
@@ -7680,11 +7626,11 @@ export function useTransientCall<T, E = unknown>({
                                                    schema,
                                                    errorSchema
                                                  }: {
-  schema?: ZodOut<T>;
-  errorSchema?: ZodOut<T>
+  schema?: SchemaOf<T>;
+  errorSchema?: SchemaOf<T>
 }): [(request: RequestType) => Promise<T>, () => void] {
   const ctx = useContext(Context);
-  const controller = useRef<AbortController>(null);
+  const controller = useRef<AbortController | undefined>(undefined);
 
   const call = useCallback(
     async (request: RequestType)=> {
@@ -13777,10 +13723,12 @@ const core_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("
 
 
 
-const isVerbose = process.argv.includes('--verbose');
 const logger = new common_namespaceObject.Logger('Main');
 async function bootstrapDeamon() {
     const app = await core_namespaceObject.NestFactory.create(AppModule, {
+        logger: [
+            'error'
+        ]
     });
     app.enableShutdownHooks();
     app.enableCors();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intrig/core",
-  "version": "0.0.15-3",
+  "version": "0.0.15-4",
   "private": false,
   "type": "module",
   "bin": {