@intrig/next 1.0.7 → 1.0.11

package/src/media-type-utils.ts

@@ -0,0 +1,184 @@
+import { ZodSchema } from 'zod';
+import { XMLParser } from 'fast-xml-parser';
+
+type Encoders = {
+  [k: string]: <T>(request: T,
+                   mediaType: string,
+                   schema: ZodSchema) => Promise<any>;
+};
+
+const encoders: Encoders = {};
+
+export function encode<T>(request: T, mediaType: string, schema: ZodSchema) {
+  if (encoders[mediaType]) {
+    return encoders[mediaType](request, mediaType, schema);
+  }
+  return request;
+}
+
+encoders['application/json'] = async (request, mediaType, schema) => {
+  return request;
+}
+
+function appendFormData(
+  formData: FormData,
+  data: any,
+  parentKey: string
+): void {
+  if (data instanceof Blob || typeof data === 'string') {
+    formData.append(parentKey, data);
+  } else if (data !== null && typeof data === 'object') {
+    if (Array.isArray(data)) {
+      data.forEach((item: any, index: number) => {
+        const key = `${parentKey}`;
+        appendFormData(formData, item, key);
+      });
+    } else {
+      Object.keys(data).forEach((key: string) => {
+        const newKey = parentKey ? `${parentKey}[${key}]` : key;
+        appendFormData(formData, data[key], newKey);
+      });
+    }
+  } else {
+    formData.append(parentKey, data == null ? '' : String(data));
+  }
+}
+
+
+encoders['multipart/form-data'] = async (request, mediaType, schema) => {
+  let _request = request as Record<string, any>;
+  let formData = new FormData();
+  Object.keys(_request).forEach((key: string) => {
+    appendFormData(formData, _request[key], key);
+  });
+  return formData;
+}
+
+encoders['application/octet-stream'] = async (request, mediaType, schema) => {
+  return request;
+}
+
+encoders['application/x-www-form-urlencoded'] = async (request, mediaType, schema) => {
+  let formData = new FormData();
+  for (let key in request) {
+    const value = request[key];
+    formData.append(key, value instanceof Blob || typeof value === 'string' ? value : String(value));
+  }
+  return formData;
+}
+
+type Transformers = {
+  [k: string]: <T>(
+    request: Request,
+    mediaType: string,
+    schema: ZodSchema
+  ) => Promise<T>;
+};
+
+const transformers: Transformers = {};
+
+export function transform<T>(
+  request: Request,
+  mediaType: string,
+  schema: ZodSchema
+): Promise<T> {
+  if (transformers[mediaType]) {
+    return transformers[mediaType](request, mediaType, schema);
+  }
+  throw new Error(`Unsupported media type: ` + mediaType);
+}
+
+transformers['application/json'] = async (request, mediaType, schema) => {
+  return schema.parse(await request.json());
+};
+
+transformers['multipart/form-data'] = async (request, mediaType, schema) => {
+  let formData = await request.formData();
+  let content: Record<string, any> = {};
+  formData.forEach((value, key) => {
+    if (content[key]) {
+      if (!(content[key] instanceof Array)) {
+        content[key] = [content[key]];
+      }
+      content[key].push(value);
+    } else {
+      content[key] = value
+    }
+  });
+  return schema.parse(content);
+};
+
+transformers['application/octet-stream'] = async (
+  request,
+  mediaType,
+  schema
+) => {
+  return schema.parse(
+    new Blob([await request.arrayBuffer()], {
+      type: 'application/octet-stream',
+    })
+  );
+};
+
+transformers['application/x-www-form-urlencoded'] = async (
+  request,
+  mediaType,
+  schema
+) => {
+  let formData = await request.formData();
+  let content: Record<string, any> = {};
+  formData.forEach((value, key) => (content[key] = value));
+  return schema.parse(content);
+};
+
+transformers['application/xml'] = async (request, mediaType, schema) => {
+  let xmlParser = new XMLParser();
+  let content = await xmlParser.parse(await request.text());
+  return schema.parse(await content);
+};
+
+transformers['text/plain'] = async (request, mediaType, schema) => {
+  return schema.parse(await request.text());
+};
+
+transformers['text/html'] = async (request, mediaType, schema) => {
+  return schema.parse(await request.text());
+};
+
+transformers['text/css'] = async (request, mediaType, schema) => {
+  return schema.parse(await request.text());
+};
+
+transformers['text/javascript'] = async (request, mediaType, schema) => {
+  return schema.parse(await request.text());
+};
+
+type ResponseTransformers = {
+  [k: string]: <T>(
+    data: any,
+    mediaType: string,
+    schema: ZodSchema
+  ) => Promise<T>;
+};
+
+const responseTransformers: ResponseTransformers = {};
+
+responseTransformers['application/json'] = async (data, mediaType, schema) => {
+  return schema.parse(data);
+};
+
+responseTransformers['application/xml'] = async (data, mediaType, schema) => {
+  let parsed = new XMLParser().parse(data);
+  return schema.parse(parsed);
+}
+
+export async function transformResponse<T>(
+  data: any,
+  mediaType: string,
+  schema: ZodSchema
+): Promise<T> {
+  if (responseTransformers[mediaType]) {
+    return await responseTransformers[mediaType](data, mediaType, schema);
+  }
+  return data
+}

package/src/{network-state.d.ts → network-state.tsx}

@@ -1,4 +1,5 @@
 import { ZodError } from 'zod';
+
 /**
  * State of an asynchronous call. Network state follows the state diagram given below.
  *
@@ -23,33 +24,44 @@ import { ZodError } from 'zod';
  * </pre>
  */
 export interface NetworkState<T = unknown, E = unknown> {
-    state: 'init' | 'pending' | 'success' | 'error';
+  state: 'init' | 'pending' | 'success' | 'error';
 }
+
 /**
  * Network call is not yet started
  */
 export interface InitState<T, E = unknown> extends NetworkState<T, E> {
-    state: 'init';
+  state: 'init';
 }
+
 /**
  * Checks whether the state is init state
  * @param state
  */
-export declare function isInit<T, E = unknown>(state: NetworkState<T, E>): state is InitState<T, E>;
+export function isInit<T, E = unknown>(state: NetworkState<T, E>): state is InitState<T, E> {
+  return state.state === 'init';
+}
+
 /**
  * Initializes a new state.
  *
  * @template T The type of the state.
  * @return {InitState<T>} An object representing the initial state.
  */
-export declare function init<T, E = unknown>(): InitState<T, E>;
+export function init<T, E = unknown>(): InitState<T, E> {
+  return {
+    state: 'init',
+  };
+}
+
 /**
  * Network call is not yet completed
  */
 export interface PendingState<T, E = unknown> extends NetworkState<T, E> {
-    state: 'pending';
-    progress?: Progress;
+  state: 'pending';
+  progress?: Progress;
 }
+
 /**
  * Interface representing progress information for an upload or download operation.
  *
@@ -62,54 +74,80 @@ export interface PendingState<T, E = unknown> extends NetworkState<T, E> {
  * @property {number} [total] - The total amount of data to be loaded (if known).
  */
 export interface Progress {
-    type?: 'upload' | 'download';
-    loaded: number;
-    total?: number;
+  type?: 'upload' | 'download';
+  loaded: number;
+  total?: number;
 }
+
 /**
  * Checks whether the state is pending state
  * @param state
  */
-export declare function isPending<T, E = unknown>(state: NetworkState<T, E>): state is PendingState<T, E>;
+export function isPending<T, E = unknown>(state: NetworkState<T, E>): state is PendingState<T, E> {
+  return state.state === 'pending';
+}
+
 /**
  * Generates a PendingState object with a state of "pending".
  *
  * @return {PendingState<T>} An object representing the pending state.
  */
-export declare function pending<T, E = unknown>(progress?: Progress | undefined): PendingState<T, E>;
+export function pending<T, E = unknown>(
+  progress: Progress | undefined = undefined
+): PendingState<T, E> {
+  return {
+    state: 'pending',
+    progress,
+  };
+}
+
 /**
  * Network call is completed with success state
  */
 export interface SuccessState<T, E = unknown> extends NetworkState<T, E> {
-    state: 'success';
-    data: T;
+  state: 'success';
+  data: T;
 }
+
 /**
  * Checks whether the state is success response
  * @param state
  */
-export declare function isSuccess<T, E = unknown>(state: NetworkState<T, E>): state is SuccessState<T, E>;
+export function isSuccess<T, E = unknown>(state: NetworkState<T, E>): state is SuccessState<T, E> {
+  return state.state === 'success';
+}
+
 /**
  * Creates a success state object with the provided data.
  *
  * @param {T} data - The data to be included in the success state.
  * @return {SuccessState<T>} An object representing a success state containing the provided data.
  */
-export declare function success<T, E = unknown>(data: T): SuccessState<T, E>;
+export function success<T, E = unknown>(data: T): SuccessState<T, E> {
+  return {
+    state: 'success',
+    data,
+  };
+}
+
 /**
  * Network call is completed with error response
  */
 export interface ErrorState<T, E = unknown> extends NetworkState<T, E> {
-    state: 'error';
-    error: E;
-    statusCode?: number;
-    request?: any;
+  state: 'error';
+  error: E;
+  statusCode?: number;
+  request?: any;
 }
+
 /**
  * Checks whether the state is error state
  * @param state
  */
-export declare function isError<T, E = unknown>(state: NetworkState<T, E>): state is ErrorState<T, E>;
+export function isError<T, E = unknown>(state: NetworkState<T, E>): state is ErrorState<T, E> {
+  return state.state === 'error';
+}
+
 /**
  * Constructs an ErrorState object representing an error.
  *
@@ -117,7 +155,19 @@ export declare function isError<T, E = unknown>(state: NetworkState<T, E>): stat
  * @param {string} [statusCode] - An optional status code associated with the error.
  * @return {ErrorState<T>} An object representing the error state.
  */
-export declare function error<T, E = unknown>(error: E, statusCode?: number, request?: any): ErrorState<T>;
+export function error<T, E = unknown>(
+  error: E,
+  statusCode?: number,
+  request?: any
+): ErrorState<T> {
+  return {
+    state: 'error',
+    error,
+    statusCode,
+    request,
+  };
+}
+
 /**
  * Represents an error state with additional contextual information.
  *
@@ -130,10 +180,11 @@ export declare function error<T, E = unknown>(error: E, statusCode?: number, req
  * @property {string} key - A unique key identifying the specific error instance.
  */
 export interface ErrorWithContext<T = unknown, E = unknown> extends ErrorState<T, E> {
-    source: string;
-    operation: string;
-    key: string;
+  source: string;
+  operation: string;
+  key: string;
 }
+
 /**
  * Represents an action in the network context.
  *
@@ -143,57 +194,37 @@ export interface ErrorWithContext<T = unknown, E = unknown> extends ErrorState<T
  * @property {string} key - The unique identifier for the network action
  */
 export interface NetworkAction<T, E> {
-    key: string;
-    source: string;
-    operation: string;
-    state: NetworkState<T, E>;
-    handled?: boolean;
+  key: string;
+  source: string;
+  operation: string;
+  state: NetworkState<T, E>;
+  handled?: boolean;
 }
+
 type HookWithKey = {
-    key: string;
-};
-export type UnitHookOptions = {
-    key?: string;
-    fetchOnMount?: false;
-    clearOnUnmount?: boolean;
-} | {
-    key?: string;
-    fetchOnMount: true;
-    params?: Record<string, any>;
-    clearOnUnmount?: boolean;
-};
+  key: string;
+}
+
+
+export type UnitHookOptions = { key?: string; fetchOnMount?: false; clearOnUnmount?: boolean } | { key?: string; fetchOnMount: true; params?: Record<string, any>; clearOnUnmount?: boolean };
 export type UnitHook<E = unknown> = ((options: UnitHookOptions) => [NetworkState<never, E>, (params?: Record<string, any>) => DispatchState<any>, () => void]) & HookWithKey;
 export type ConstantHook<T, E = unknown> = ((options: UnitHookOptions) => [NetworkState<T, E>, (params?: Record<string, any>) => DispatchState<any>, () => void]) & HookWithKey;
-export type UnaryHookOptions<P> = {
-    key?: string;
-    fetchOnMount?: false;
-    clearOnUnmount?: boolean;
-} | {
-    key?: string;
-    fetchOnMount: true;
-    params: P;
-    clearOnUnmount?: boolean;
-};
+
+export type UnaryHookOptions<P> = { key?: string, fetchOnMount?: false, clearOnUnmount?: boolean } | { key?: string, fetchOnMount: true, params: P, clearOnUnmount?: boolean };
 export type UnaryProduceHook<P, E = unknown> = ((options?: UnaryHookOptions<P>) => [NetworkState<never, E>, (params: P) => DispatchState<any>, () => void]) & HookWithKey;
 export type UnaryFunctionHook<P, T, E = unknown> = ((options?: UnaryHookOptions<P>) => [NetworkState<T, E>, (params: P) => DispatchState<any>, () => void]) & HookWithKey;
-export type BinaryHookOptions<P, B> = {
-    key?: string;
-    fetchOnMount?: false;
-    clearOnUnmount?: boolean;
-} | {
-    key?: string;
-    fetchOnMount: true;
-    params: P;
-    body: B;
-    clearOnUnmount?: boolean;
-};
+
+export type BinaryHookOptions<P, B> = { key?: string, fetchOnMount?: false, clearOnUnmount?: boolean } | { key?: string, fetchOnMount: true, params: P, body: B, clearOnUnmount?: boolean };
 export type BinaryProduceHook<P, B, E = unknown> = ((options?: BinaryHookOptions<P, B>) => [NetworkState<never, E>, (body: B, params: P) => DispatchState<any>, () => void]) & HookWithKey;
 export type BinaryFunctionHook<P, B, T, E = unknown> = ((options?: BinaryHookOptions<P, B>) => [NetworkState<T, E>, (body: B, params: P) => DispatchState<any>, () => void]) & HookWithKey;
+
 export type IntrigHookOptions<P = undefined, B = undefined> = UnitHookOptions | UnaryHookOptions<P> | BinaryHookOptions<P, B>;
 export type IntrigHook<P = undefined, B = undefined, T = any, E = unknown> = UnitHook<E> | ConstantHook<T, E> | UnaryProduceHook<P, E> | UnaryFunctionHook<P, T, E> | BinaryProduceHook<P, B, E> | BinaryFunctionHook<P, B, T, E>;
+
 export interface AsyncRequestOptions {
-    hydrate?: boolean;
+  hydrate?: boolean;
 }
+
 /**
  * Represents the dispatch state of a process.
  *
@@ -203,8 +234,9 @@ export interface AsyncRequestOptions {
  * @property {string} state The current state of the dispatch process.
  */
 export interface DispatchState<T> {
-    state: string;
+  state: string
 }
+
 /**
  * Represents a successful dispatch state.
  *
@@ -214,46 +246,65 @@ export interface DispatchState<T> {
  *
  * @property {string} state - The state of the dispatch, always 'success'.
  */
-export interface SuccessfulDispatch<T> extends DispatchState<T> {
-    state: 'success';
+export interface SuccessfulDispatch<T> extends DispatchState<T>{
+  state: 'success'
 }
+
 /**
  * Indicates a successful dispatch state.
  *
  * @return {DispatchState<T>} An object representing a successful state.
  */
-export declare function successfulDispatch<T>(): DispatchState<T>;
+export function successfulDispatch<T>(): DispatchState<T> {
+  return {
+    state: 'success'
+  }
+}
+
 /**
  * Determines if the provided dispatch state represents a successful dispatch.
  *
  * @param {DispatchState<T>} value - The dispatch state to check.
  * @return {value is SuccessfulDispatch<T>} - True if the dispatch state indicates success, false otherwise.
  */
-export declare function isSuccessfulDispatch<T>(value: DispatchState<T>): value is SuccessfulDispatch<T>;
+export function isSuccessfulDispatch<T>(value: DispatchState<T>): value is SuccessfulDispatch<T> {
+  return value.state === 'success'
+}
+
 /**
  * ValidationError interface represents a specific type of dispatch state
  * where a validation error has occurred.
  *
  * @typeparam T - The type of the data associated with this dispatch state.
  */
-export interface ValidationError<T> extends DispatchState<T> {
-    state: 'validation-error';
-    error: any;
+export interface ValidationError<T> extends DispatchState<T>{
+  state: 'validation-error'
+  error: any
 }
+
 /**
  * Generates a ValidationError object.
  *
  * @param error The error details that caused the validation to fail.
  * @return The ValidationError object containing the error state and details.
  */
-export declare function validationError<T>(error: any): ValidationError<T>;
+export function validationError<T>(error: any): ValidationError<T> {
+  return {
+    state: 'validation-error',
+    error
+  }
+}
+
 /**
  * Determines if a provided DispatchState object is a ValidationError.
  *
  * @param {DispatchState<T>} value - The DispatchState object to evaluate.
  * @return {boolean} - Returns true if the provided DispatchState object is a ValidationError, otherwise returns false.
  */
-export declare function isValidationError<T>(value: DispatchState<T>): value is ValidationError<T>;
+export function isValidationError<T>(value: DispatchState<T>): value is ValidationError<T> {
+  return value.state === 'validation-error'
+}
+
 /**
  * Represents an error structure with a specified type and associated data.
  *
@@ -263,8 +314,9 @@ export declare function isValidationError<T>(value: DispatchState<T>): value is
  * @property {string} type - A string representing the type of the error.
  */
 export interface IntrigError<T, E> {
-    type: string;
+  type: string
 }
+
 /**
  * Represents an error encountered during a network operation.
  * Extends from the `IntrigError` interface, adding network-specific properties.
@@ -277,12 +329,13 @@ export interface IntrigError<T, E> {
  * @property {E} error - The detailed error information specific to the failure, type extends from the generic E, allowing flexibility in the error details.
  * @property {any} request - The request object that was attempted when the network error occurred, providing context for what operation failed.
  */
-export interface NetworkError<T, E = unknown> extends IntrigError<T, E> {
-    type: 'network';
-    statusCode: string;
-    error: E;
-    request: any;
+export interface NetworkError<T, E = unknown> extends IntrigError<T, E>{
+  type: 'network'
+  statusCode: string
+  error: E
+  request: any
 }
+
 /**
  * Constructs a network error object.
  *
@@ -291,14 +344,25 @@ export interface NetworkError<T, E = unknown> extends IntrigError<T, E> {
  * @param request The request object associated with the network operation.
  * @return A NetworkError object containing the error type, status code, error details, and the original request.
  */
-export declare function networkError<T, E>(error: E, statusCode: string, request: any): NetworkError<T, E>;
+export function networkError<T, E>(error: E, statusCode: string, request: any): NetworkError<T, E> {
+  return {
+    type: 'network',
+    statusCode,
+    error,
+    request
+  }
+}
+
 /**
  * Determines if the provided IntrigError is of type 'network'.
  *
  * @param {IntrigError<T, E>} value - The error value to check the type of.
  * @return {boolean} - Returns true if the error is of type 'network', otherwise false.
  */
-export declare function isNetworkError<T, E>(value: IntrigError<T, E>): value is NetworkError<T, E>;
+export function isNetworkError<T, E>(value: IntrigError<T, E>): value is NetworkError<T, E> {
+  return value.type === 'network'
+}
+
 /**
  * Interface representing a request validation error.
  *
@@ -313,24 +377,34 @@ export declare function isNetworkError<T, E>(value: IntrigError<T, E>): value is
  * @property {string} type - A string literal indicating the error type as 'request-validation'.
  * @property {ZodError} error - An instance of ZodError containing detailed validation error information.
  */
-export interface RequestValidationError<T, E = unknown> extends IntrigError<T, E> {
-    type: 'request-validation';
-    error: ZodError;
+export interface RequestValidationError<T, E = unknown> extends IntrigError<T, E>{
+  type: 'request-validation'
+  error: ZodError
 }
+
 /**
  * Constructs a RequestValidationError object encapsulating the ZodError.
  *
  * @param {ZodError} error - The error object resulting from Zod schema validation.
  * @return {RequestValidationError<T, E>} A RequestValidationError object containing the validation error information.
  */
-export declare function requestValidationError<T, E>(error: ZodError): RequestValidationError<T, E>;
+export function requestValidationError<T, E>(error: ZodError): RequestValidationError<T, E> {
+  return {
+    type: 'request-validation',
+    error
+  }
+}
+
 /**
  * Determines if a given error is of type RequestValidationError.
  *
  * @param value The error object to check, which implements the IntrigError interface.
  * @return A boolean indicating whether the error is a RequestValidationError.
  */
-export declare function isRequestValidationError<T, E>(value: IntrigError<T, E>): value is RequestValidationError<T, E>;
+export function isRequestValidationError<T, E>(value: IntrigError<T, E>): value is RequestValidationError<T, E> {
+  return value.type === 'request-validation'
+}
+
 /**
  * ResponseValidationError interface is designed to extend the capabilities of the IntrigError interface,
  * specifically for handling errors related to response validation.
@@ -343,22 +417,30 @@ export declare function isRequestValidationError<T, E>(value: IntrigError<T, E>)
  * @property type - A string literal that identifies the type of error as 'response-validation'.
  * @property error - An instance of ZodError representing the validation error encountered.
  */
-export interface ResponseValidationError<T, E = unknown> extends IntrigError<T, E> {
-    type: 'response-validation';
-    error: ZodError;
+export interface ResponseValidationError<T, E = unknown> extends IntrigError<T, E>{
+  type: 'response-validation'
+  error: ZodError
 }
+
 /**
  * Constructs a ResponseValidationError object with a specified error.
  *
  * @param {ZodError} error - The validation error encountered during response validation.
  * @return {ResponseValidationError<T, E>} An error object containing the type of error and the validation error details.
  */
-export declare function responseValidationError<T, E>(error: ZodError): ResponseValidationError<T, E>;
+export function responseValidationError<T, E>(error: ZodError): ResponseValidationError<T, E> {
+  return {
+    type: 'response-validation',
+    error
+  }
+}
+
 /**
  * Determines if the given error is a response validation error.
  *
  * @param {IntrigError<T, E>} value - The error object to assess.
  * @return {boolean} True if the error is a response validation error, otherwise false.
  */
-export declare function isResponseValidationError<T, E>(value: IntrigError<T, E>): value is ResponseValidationError<T, E>;
-export {};
+export function isResponseValidationError<T, E>(value: IntrigError<T, E>): value is ResponseValidationError<T, E> {
+  return value.type === 'response-validation'
+}

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "declaration": true,
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "moduleResolution": "node",
+    "baseUrl": ".",
+    "paths": {
+      "@intrig/next/*": ["./src/*"],
+      "intrig-hook": ["src/config/intrig"]
+    },
+    "jsx": "react-jsx"
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}