@intrig/core 0.0.15-3 → 0.0.15-5

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)=> {
@@ -8151,6 +8097,15 @@ async function reactDownloadHookTemplate({ source, data: { paths, operationId, r
         "...params"
     ].join(",");
     const finalRequestBodyBlock = requestBody ? `,data: encode(data, "${contentType}", requestBodySchema)` : '';
+    function responseTypePart() {
+        switch(responseType){
+            case "application/octet-stream":
+                return `responseType: 'blob', adapter: 'fetch',`;
+            case "text/event-stream":
+                return `responseType: 'stream', adapter: 'fetch',`;
+        }
+        return '';
+    }
     return ts`
     ${[
         ...imports
@@ -8229,7 +8184,7 @@ async function reactDownloadHookTemplate({ source, data: { paths, operationId, r
             key: \`${"${source}: ${operation}"}\`,
             source: '${source}'
             ${requestBody ? finalRequestBodyBlock : ''},
-            ${responseType === "text/event-stream" ? `responseType: 'stream', adapter: 'fetch',` : ''}
+            ${responseTypePart()}
           })
           return successfulDispatch();
       }, [dispatch])
@@ -9370,23 +9325,8 @@ function typeUtilsTemplate(_path) {
     const ts = typescript(external_path_default().resolve(_path, 'src', 'type-utils.ts'));
     return ts`import { z } from 'zod';
 
-export type BinaryData = Blob | ArrayBuffer | Uint8Array;
-
-export const BinaryDataSchema = z.union([
-  // Blob in browsers
-  z.instanceof(Blob).optional(), // optional here so union below still validates if Blob is absent in Node
-  // Raw buffers
-  z.instanceof(ArrayBuffer),
-  z.custom<Uint8Array>((v) => v instanceof Uint8Array, { message: 'Expected Uint8Array' }),
-]).transform((v) => {
-  // Normalize to Blob if possible (nice for downloads in browser)
-  if (typeof Blob !== 'undefined') {
-    if (v instanceof Blob) return v;
-    if (v instanceof ArrayBuffer) return new Blob([v]);
-    if (v instanceof Uint8Array) return new Blob([v.buffer]);
-  }
-  return v;
-});
+export type BinaryData = Blob;
+export const BinaryDataSchema: z.ZodType<BinaryData> = z.instanceof(Blob);
 
 // Base64 helpers (browser + Node compatible; no Buffer required)
 export function base64ToUint8Array(b64: string): Uint8Array {
@@ -13777,10 +13717,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-5",
   "private": false,
   "type": "module",
   "bin": {