@intrig/plugin-react 0.0.1 → 0.0.2-2

package/src/lib/templates/provider/intrig-provider-stub.template.ts

@@ -1,73 +0,0 @@
-import { IntrigSourceConfig, typescript } from "@intrig/plugin-sdk";
-import * as path from 'path';
-
-export function reactIntrigProviderStubTemplate(_apisToSync: IntrigSourceConfig[]) {
-  const ts = typescript(path.resolve('src', 'intrig-provider-stub.tsx'));
-  return ts`import { useMemo, useReducer } from 'react';
-import { ZodSchema } from 'zod';
-import { Context, RequestType, GlobalState } from './intrig-context';
-import { IntrigProviderStubProps } from './interfaces';
-import { error, configError, init, NetworkState } from './network-state';
-import { requestReducer } from './reducer';
-
-export function IntrigProviderStub({
-  children,
-  configs = {},
-  stubs = () => {
-    //intentionally left blank
-  },
-}: IntrigProviderStubProps) {
-  const [state, dispatch] = useReducer(requestReducer, {} as GlobalState);
-
-  const collectedStubs = useMemo(() => {
-    const fns: Record<string, (
-      params: any,
-      body: any,
-      dispatch: (state: NetworkState<any>) => void,
-    ) => Promise<void>> = {};
-    function stub<P, B, T>(
-      hook: any,
-      fn: (
-        params: P,
-        body: B,
-        dispatch: (state: NetworkState<T>) => void,
-      ) => Promise<void>,
-    ) {
-      fns[hook.key] = fn;
-    }
-    stubs(stub);
-    return fns;
-  }, [stubs]);
-
-  const contextValue = useMemo(() => {
-    async function execute<T>(
-      request: RequestType,
-      dispatch: (state: NetworkState<T>) => void,
-      schema: ZodSchema<T> | undefined,
-    ) {
-      const stub = collectedStubs[request.key];
-
-      if (stub) {
-        try {
-          await stub(request.params, request.data, dispatch);
-        } catch (e: any) {
-          dispatch(error(configError(e?.message ?? '')));
-        }
-      } else {
-        dispatch(init());
-      }
-    }
-
-    return {
-      state,
-      dispatch,
-      filteredState: state,
-      configs,
-      execute,
-    };
-  }, [state, dispatch, configs, collectedStubs]);
-
-  return <Context.Provider value={contextValue}>{children}</Context.Provider>;
-}
-`;
-}

package/src/lib/templates/provider/intrig-provider.template.ts

@@ -1,185 +0,0 @@
-import { IntrigSourceConfig, typescript } from "@intrig/plugin-sdk";
-import * as path from 'path';
-
-export function reactIntrigProviderTemplate(_apisToSync: IntrigSourceConfig[]) {
-  const ts = typescript(path.resolve('src', 'intrig-provider.tsx'));
-  return ts`import React, { useMemo, useReducer } from 'react';
-import {
-  error,
-  NetworkState,
-  pending,
-  success,
-  responseValidationError,
-  configError,
-  httpError,
-  networkError,
-} from './network-state';
-import { Axios, AxiosResponse, isAxiosError } from 'axios';
-import { ZodError, ZodSchema } from 'zod';
-import { flushSync } from 'react-dom';
-import { createParser } from 'eventsource-parser';
-
-import { Context, RequestType, GlobalState } from './intrig-context';
-import { IntrigProviderProps } from './interfaces';
-import { createAxiosInstances } from './axios-config';
-import { requestReducer, inferNetworkReason } from './reducer';
-
-/**
- * IntrigProvider is a context provider component that sets up global state management
- * and provides Axios instances for API requests.
- */
-export function IntrigProvider({ children, configs = {} }: IntrigProviderProps) {
-  const [state, dispatch] = useReducer(requestReducer, {} as GlobalState);
-
-  const axiosInstances: Record<string, Axios> = useMemo(() => {
-    return createAxiosInstances(configs);
-  }, [configs]);
-
-  const contextValue = useMemo(() => {
-    async function execute<T>(
-      request: RequestType,
-      setState: (s: NetworkState<T>) => void,
-      schema?: ZodSchema<T>,          // success payload schema (optional)
-      errorSchema?: ZodSchema<any>,   // error-body schema for non-2xx (optional)
-    ) {
-      try {
-        setState(pending());
-
-        const axios = axiosInstances[request.source];
-        if (!axios) {
-          setState(error(configError(${"`Unknown axios source '${request.source}'`"})));
-          return;
-        }
-
-        const response = await axios.request(request);
-        const status  = response.status;
-        const method  = (response.config?.method || 'GET').toUpperCase();
-        const url     = response.config?.url || '';
-        const ctype   = String(response.headers?.['content-type'] || '');
-
-        // -------------------- 2xx branch --------------------
-        if (status >= 200 && status < 300) {
-          // SSE stream
-          if (ctype.includes('text/event-stream')) {
-            const reader  = response.data.getReader();
-            const decoder = new TextDecoder();
-
-            let lastMessage: any;
-
-            const parser = createParser({
-              onEvent(evt) {
-                let decoded: unknown = evt.data;
-
-                // Try JSON parse; if schema is defined, we require valid JSON for validation
-                try {
-                  let parsed: unknown = JSON.parse(String(decoded));
-                  if (schema) {
-                    const vr = schema.safeParse(parsed);
-                    if (!vr.success) {
-                      setState(error(responseValidationError(vr.error, parsed)));
-                      return;
-                    }
-                    parsed = vr.data;
-                  }
-                  decoded = parsed;
-                } catch (ignore) {
-                  if (schema) {
-                    // schema expects structured data but chunk wasn't JSON
-                    setState(error(responseValidationError(new ZodError([]), decoded)));
-                    return;
-                  }
-                  // if no schema, pass raw text
-                }
-
-                lastMessage = decoded;
-                flushSync(() => setState(pending(undefined, decoded as T)));
-              },
-            });
-
-            while (true) {
-              const { done, value } = await reader.read();
-              if (done) {
-                flushSync(() => setState(success(lastMessage as T, response.headers)));
-                break;
-              }
-              parser.feed(decoder.decode(value, { stream: true }));
-            }
-            return;
-          }
-
-          // Non-SSE: validate body if a schema is provided
-          if (schema) {
-            const parsed = schema.safeParse(response.data);
-            if (!parsed.success) {
-              setState(error(responseValidationError(parsed.error, response.data)));
-              return;
-            }
-            setState(success(parsed.data, response.headers));
-            return;
-          }
-
-          // No schema → pass through
-          setState(success(response.data as T, response.headers));
-          return;
-        }
-
-        // -------------------- non-2xx (HTTP error) --------------------
-        let errorBody: unknown = response.data;
-
-        if (errorSchema) {
-          const ev = errorSchema.safeParse(errorBody ?? {});
-          if (!ev.success) {
-            setState(error(responseValidationError(ev.error, errorBody)));
-            return;
-          }
-          errorBody = ev.data;
-        }
-
-        setState(error(httpError(status, url, method, response.headers, errorBody)));
-
-      } catch (e: any) {
-        // -------------------- thrown / transport --------------------
-        if (isAxiosError(e)) {
-          const status = e.response?.status;
-          const method = (e.config?.method || 'GET').toUpperCase();
-          const url    = e.config?.url || '';
-
-          if (status != null) {
-            // HTTP error with response
-            let errorBody: unknown = e.response?.data;
-
-            if (errorSchema) {
-              const ev = errorSchema.safeParse(errorBody ?? {});
-              if (!ev.success) {
-                setState(error(responseValidationError(ev.error, errorBody)));
-                return;
-              }
-              errorBody = ev.data;
-            }
-
-            setState(error(httpError(status, url, method, e.response?.headers, errorBody)));
-            return;
-          }
-
-          // No response → network layer
-          setState(error(networkError(inferNetworkReason(e), e.request)));
-          return;
-        }
-
-        // Non-Axios exception → treat as unknown network-ish failure
-        setState(error(networkError('unknown')));
-      }
-    }
-    return {
-      state,
-      dispatch,
-      filteredState: state,
-      configs,
-      execute,
-    };
-  }, [state, axiosInstances]);
-
-  return <Context.Provider value={contextValue}>{children}</Context.Provider>;
-}
-`;
-}

package/src/lib/templates/provider/main.template.ts

@@ -1,48 +0,0 @@
-import {IntrigSourceConfig, typescript} from "@intrig/plugin-sdk";
-import * as path from 'path'
-
-export function providerMainTemplate(apisToSync: IntrigSourceConfig[]) {
-  const ts = typescript(path.resolve("src", "intrig-provider-main.tsx"))
-  return ts`// Re-export all provider functionality from modular templates
-export * from './interfaces';
-export * from './reducer';
-export * from './axios-config';
-export * from './intrig-provider';
-export * from './intrig-provider-stub';
-export * from './status-trap';
-export * from './provider-hooks';
-
-// Main provider exports for backward compatibility
-export { IntrigProvider } from './intrig-provider';
-export { IntrigProviderStub } from './intrig-provider-stub';
-export { StatusTrap } from './status-trap';
-
-export {
-  useNetworkState,
-  useTransitionCall,
-  useCentralError,
-  useCentralPendingState,
-} from './provider-hooks';
-
-export {
-  requestReducer,
-  inferNetworkReason,
-  debounce,
-} from './reducer';
-
-export {
-  createAxiosInstance,
-  createAxiosInstances,
-} from './axios-config';
-
-export type {
-  DefaultConfigs,
-  IntrigProviderProps,
-  IntrigProviderStubProps,
-  StatusTrapProps,
-  NetworkStateProps,
-  StubType,
-  WithStubSupport,
-} from './interfaces';
-  `
-}

package/src/lib/templates/provider/reducer.template.ts

@@ -1,50 +0,0 @@
-import {typescript} from "@intrig/plugin-sdk";
-import * as path from 'path'
-
-export function providerReducerTemplate() {
-  const ts = typescript(path.resolve("src", "reducer.ts"))
-  return ts`import {
-  NetworkAction,
-} from './network-state';
-import { GlobalState } from './intrig-context';
-
-/**
- * Handles state updates for network requests based on the provided action.
- *
- * @param {GlobalState} state - The current state of the application.
- * @param {NetworkAction<unknown>} action - The action containing source, operation, key, and state.
- * @return {GlobalState} - The updated state after applying the action.
- */
-export function requestReducer(
-  state: GlobalState,
-  action: NetworkAction<unknown>,
-): GlobalState {
-  return {
-    ...state,
-    [${"`${action.source}:${action.operation}:${action.key}`"}]: action.state,
-  };
-}
-
-function inferNetworkReason(e: any): 'timeout' | 'dns' | 'offline' | 'aborted' | 'unknown' {
-  if (e?.code === 'ECONNABORTED') return 'timeout';
-  if (typeof navigator !== 'undefined' && navigator.onLine === false) return 'offline';
-  if (e?.name === 'AbortError') return 'aborted';
-  return 'unknown';
-}
-
-function debounce<T extends (...args: any[]) => void>(func: T, delay: number) {
-  let timeoutId: any;
-
-  return (...args: Parameters<T>) => {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-    }
-    timeoutId = setTimeout(() => {
-      func(...args);
-    }, delay);
-  };
-}
-
-export { inferNetworkReason, debounce };
-  `
-}

package/src/lib/templates/provider/status-trap.template.ts

@@ -1,80 +0,0 @@
-import { IntrigSourceConfig, typescript } from "@intrig/plugin-sdk";
-import * as path from 'path';
-
-export function reactStatusTrapTemplate(_apisToSync: IntrigSourceConfig[]) {
-  const ts = typescript(path.resolve('src', 'status-trap.tsx'));
-  return ts`import React, { PropsWithChildren, useCallback, useContext, useMemo, useState } from 'react';
-import { isError, isPending, NetworkState } from './network-state';
-import { Context } from './intrig-context';
-import { StatusTrapProps } from './interfaces';
-
-/**
- * StatusTrap component is used to track and manage network request states.
- */
-export function StatusTrap({
-  children,
-  type,
-  propagate = true,
-}: PropsWithChildren<StatusTrapProps>) {
-  const ctx = useContext(Context);
-
-  const [requests, setRequests] = useState<string[]>([]);
-
-  const shouldHandleEvent = useCallback(
-    (state: NetworkState) => {
-      switch (type) {
-        case 'error':
-          return isError(state);
-        case 'pending':
-          return isPending(state);
-        case 'pending + error':
-          return isPending(state) || isError(state);
-        default:
-          return false;
-      }
-    },
-    [type],
-  );
-
-  const dispatch = useCallback(
-    (event: any) => {
-      const composite = ${"`${event.source}:${event.operation}:${event.key}`"};
-      if (!event.handled) {
-        if (shouldHandleEvent(event.state)) {
-          setRequests((prev) => [...prev, composite]);
-          if (!propagate) {
-            ctx.dispatch({
-              ...event,
-              handled: true,
-            });
-            return;
-          }
-        } else {
-          setRequests((prev) => prev.filter((k) => k !== composite));
-        }
-      }
-      ctx.dispatch(event);
-    },
-    [ctx, propagate, shouldHandleEvent],
-  );
-
-  const filteredState = useMemo(() => {
-    return Object.fromEntries(
-      Object.entries(ctx.state).filter(([key]) => requests.includes(key)),
-    );
-  }, [ctx.state, requests]);
-
-  return (
-    <Context.Provider
-      value={{
-        ...ctx,
-        dispatch,
-        filteredState,
-      }}
-    >
-      {children}
-    </Context.Provider>
-  );
-}
-`;
-}