@apia/api 3.0.1 → 3.0.2

package/dist/index.d.ts

@@ -1,5 +1,298 @@
-export { ApiaApiHandler, TApiaApiMethod, getFunction } from './ApiaApiHandler.js';
-export { default as ApiaApi, TApiaApiAxiosResponse, makeApiaUrl } from './apiaApi.js';
-export { IApiaApiRequestConfig, TApiaApiResult } from './types.js';
-export { getModal } from './fields/ApiaApiInput.js';
+import * as React from 'react';
+import React__default from 'react';
+import { AxiosResponse, AxiosRequestConfig } from 'axios';
+import { TApiaFilter, TModify, TApiaLoad, TApiaFormElement } from '@apia/util';
+import { TNotificationMessage, notify } from '@apia/notifications';
+import { TModal } from '@apia/components';
+import QueryString from 'qs';
+import { TResponsiveTableColumn } from '@apia/table';
+
+declare function getConfig<LoadType>(outerBehaveConfig?: IApiaApiRequestConfig<LoadType>): IApiaApiRequestConfig<unknown> & IApiaApiRequestConfig<LoadType> & Partial<IApiaApiRequestConfig<unknown>>;
+type TApiaApiAxiosResponse<LoadType> = AxiosResponse<LoadType | null> & {
+    hasError: boolean;
+    hasMessages: boolean;
+};
+/**
+* IMPORTANT!! The ApiaApi is programmed under the slogan that
+ * **should never throw an exception**. **Errors** coming from
+ * connectivity or exceptions on the server **will be handled
+ * automatically** by ApiaApi, using the notification system
+ * of the application. It is possible to determine in what context they should
+ * be thrown those exceptions (global, main, modal) using the
+ * alertsCategory configuration properties **(see errorsHandling.md)**.
+ *
+ * @param url String, the url you want to call
+ * @param config interface IApiaApiRequestConfig<DataType>;
+ *
+ * @throws Nothing
+ *
+ * @example
+ *
+ * ApiaApi.post<ResponseType>('url...', {
+    axiosConfig?: AxiosRequestConfig;
+
+    // Configuración de postData
+    postData? unknown;
+    postDataTreatement?: 'stringify' | undefined;
+
+    // Configuración de queryString
+    queryData?: string | Record<string, unknown>;
+    stringifyOptions?: QueryString.IStringifyOptions;
+
+    // Response validator,
+    // If it returns true, everything continues correctly
+    // If it returns false, the ApiaApi throws a standard error.
+    // If it returns string, ApiaApi throws the error returned in the string.
+    validateResponse?: (
+      response: AxiosResponse<DataType | null>,
+    ) => boolean | string;
+
+    // Configuración de alertas
+    alertsImportance?: TAlertImportance;
+
+    // Configuración de ApiaApiHandler, falta documentar
+    handleLoad?: boolean;
+    eventsHandler?: IEventsHandler;
+
+    // other configuration
+    colors?: TColors;
+    debug?: boolean;
+  }
+ * @returns The type of the return value depends on the type passed when calling the function. If there was an error it returns null.
+ */
+declare function post<LoadType extends Record<string, unknown> = Record<string, unknown>, DataType = unknown>(url: string | TModify<IApiaApiRequestConfig<LoadType>, {
+    postData?: DataType;
+    postDataTreatement?: 'stringify';
+}>, config?: TModify<IApiaApiRequestConfig<LoadType>, {
+    postData?: DataType;
+    postDataTreatement?: 'stringify';
+}>): TApiaApiResult<LoadType>;
+declare function post<LoadType extends Record<string, unknown> = Record<string, unknown>, DataType = unknown>(config: TModify<IApiaApiRequestConfig<LoadType>, {
+    postData?: DataType;
+    postDataTreatement?: 'stringify';
+}>): TApiaApiResult<LoadType>;
+/**
+ * IMPORTANTE!! El ApiaApi está programado bajo la consigna de que
+ * **no debe tirar núnca una excepción**. **Los errores** provenientes
+ * de la conectividad o de excepciones en el servidor **serán manejados
+ * automáticamente** por el ApiaApi utilizando el sistema de notificaciones
+ * de la aplicación. Es posible determinar en qué contexto deben
+ * ser lanzadas esas excepciones (global, main, modal) utilizando las
+ * propiedades de configuración alertsCategory **(ver errorsHandling.md)**.
+ *
+ * @param url String, el url al que se desea llamar
+ * @param config interface IApiaApiRequestConfig<DataType>;
+ *
+ * @throws Nothing
+ *
+ * @example
+ *
+ * ApiaApi.get<TipoDeRespuesta>('url...', {
+    axiosConfig?: AxiosRequestConfig;
+
+    // Configuración de queryString
+    queryData?: string | Record<string, unknown>;
+    stringifyOptions?: QueryString.IStringifyOptions;
+
+    // Validador de respuesta,
+    // Si devuelve true, todo sigue correctamente
+    // Si devuelve false, el ApiaApi tira un error estándar.
+    // Si devuelve string, el ApiaApi tira el error devuelto en el string.
+    validateResponse?: (
+      response: AxiosResponse<DataType | null>,
+    ) => boolean | string;
+
+    // Configuración de alertas
+    alertsImportance?: TAlertImportance;
+
+    // Configuración de ApiaApiHandler, falta documentar
+    handleLoad?: boolean;
+    eventsHandler?: IEventsHandler;
+
+    // Otra configuración
+    colors?: TColors;
+    debug?: boolean;
+  }
+ * @returns El tipo del valor devuelto depende del tipo pasado al llamar a la función. Si hubo un error devuelve null
+ */
+declare function get<LoadType extends Record<string, unknown> = Record<string, unknown>>(url: string | IApiaApiRequestConfig<LoadType>, config?: IApiaApiRequestConfig<LoadType>): TApiaApiResult<LoadType>;
+declare function get<LoadType extends Record<string, unknown> = Record<string, unknown>>(config: IApiaApiRequestConfig<LoadType>): TApiaApiResult<LoadType>;
+declare const ApiaApi: {
+    get: typeof get;
+    getConfig: typeof getConfig;
+    post: typeof post;
+};
+/**
+ * Creates an url based on the general requirements of Apia.
+ * If the ajaxUrl property is not passed, it will use the
+ * window.URL_REQUEST_AJAX. Its use is very simple, just pass the objects you
+ * want to appear in the query string.
+ *
+ * @example makeApiaUrl({
+ *   ajaxUrl: 'the.endpoint.you.want',
+ *   queryString: 'an=existent&query=string',
+ *   action: 'theAction',
+ *   anotherProp: 15
+ * })
+ *
+ * @returns the well formed url, in the example, the response url is:
+ * /context/the.endpoint.you.want?an=existent&query=string&anotherProp=15&tabId=...&tokenId=...&action=theAction
+ */
+declare function makeApiaUrl(props?: {
+    action?: string;
+    ajaxUrl?: string;
+    queryString?: string;
+    stringifyOptions?: QueryString.IStringifyOptions;
+    tabId?: string | number;
+    preventAsXmlParameter?: boolean;
+    avoidTabId?: boolean;
+    [key: string]: unknown;
+}): string;
+declare global {
+    interface Window {
+        TAB_ID_REQUEST: string;
+        CONTEXT: string;
+        URL_REQUEST_AJAX: string;
+        FILTERS_LABEL: string;
+        BTN_DELETE_FILTERS: string;
+        FINDER_ORDER_BY: string;
+        FINDER_FILTERS: string;
+        ADDITIONAL_FILTERS_LABEL: string;
+    }
+    const usersModal: {
+        columns: TResponsiveTableColumn[];
+        filters: TApiaFilter[];
+        label: string;
+        path: string;
+    };
+    const poolsModal: {
+        columns: TResponsiveTableColumn[];
+        filters: TApiaFilter[];
+        label: string;
+        path: string;
+    };
+    const environmentsModal: {
+        columns: TResponsiveTableColumn[];
+        filters: TApiaFilter[];
+        label: string;
+        path: string;
+    };
+    const orgRolesModal: {
+        columns: TResponsiveTableColumn[];
+        filters: TApiaFilter[];
+        label: string;
+        path: string;
+    };
+    const tasksModal: {
+        columns: TResponsiveTableColumn[];
+        filters: TApiaFilter[];
+        label: string;
+        path: string;
+    };
+    const processesModal: {
+        columns: TResponsiveTableColumn[];
+        filters: TApiaFilter[];
+        label: string;
+        path: string;
+    };
+}
+
+interface TColors {
+    exception?: string;
+    alert?: string;
+    message?: string;
+}
+type TApiaApiResult<LoadType> = Promise<TApiaApiAxiosResponse<(LoadType & TNotificationMessage) | null> | null>;
+interface IApiaApiConsoleConfig {
+    colors?: TColors;
+    debug?: boolean;
+}
+type TSetModalProps = (configuration: THandleConfiguration, formDefinition?: TApiaLoad) => TModal | null;
+interface IApiaApiRequestConfig<DataType> extends IApiaApiConsoleConfig {
+    axiosConfig?: AxiosRequestConfig;
+    modalConfiguration?: IModalConfig;
+    handleLoad?: boolean;
+    setModalProps?: TSetModalProps;
+    /**
+     * Algunas veces las funciones llamadas por una acción en el servidor
+     * tienen el mismo nombre siendo en realidad funciones distintas. Para
+     * corregir este problema es posible pasar un path relativo al directorio
+     * apiaApi/methods
+     */
+    methodsPath?: string;
+    notificationsCategory?: string;
+    queryData?: string | Record<string, unknown>;
+    stringifyOptions?: QueryString.IStringifyOptions;
+    validateResponse?: (response: AxiosResponse<DataType | null>) => Promise<boolean | string> | boolean | string;
+}
+
+type TMethod = {
+    name: string;
+    props: {
+        attributes?: Record<string, unknown>;
+        currentUrl?: string;
+        funCall?: string;
+        inlineArguments?: string[];
+        messages?: unknown;
+    };
+};
+type TApiaApiMethodHandler = {
+    alert: typeof notify;
+    close: () => void;
+    configuration?: THandleConfiguration;
+    formDefinition: TApiaLoad;
+    setModalProps?: (configuration: THandleConfiguration, formDefinition?: TApiaLoad) => TModal | null;
+    reset: () => void;
+    setError: typeof notify;
+    setMessage: (message: Record<string, unknown>) => unknown;
+    setState: React.Dispatch<React.SetStateAction<IApiaApiHandlerState>>;
+    state: IApiaApiHandlerState;
+    setValue: (name: string, value: string) => void;
+};
+type TApiaApiMethod = (handler: TApiaApiMethodHandler, props: TMethod['props']) => Promise<void> | void;
+type TApiaApiField = TApiaApiMethodHandler & {
+    element: TModify<TApiaFormElement, {
+        onChange: React.ChangeEventHandler;
+    }>;
+};
+type TStoredApiaApiMethod = (props?: TMethod['props']) => unknown;
+/**
+ * Este método permite cargar en forma asíncrona un método que se encuentre
+ * dentro del directorio /api/methods
+ */
+declare function getFunction(name: string, handler: TApiaApiMethodHandler): Promise<TStoredApiaApiMethod | undefined>;
+interface IModalConfig {
+    modalTitle?: string;
+    onClose?: () => void;
+    onMessage?: (message: Record<string, unknown>) => unknown;
+    onMessageClose?: () => unknown;
+    onSubmitted?: (handler: TApiaApiMethodHandler, response: AxiosResponse<Record<string, unknown> | null> | null) => unknown;
+}
+type THandleConfiguration = Partial<Pick<IApiaApiRequestConfig<unknown>, 'modalConfiguration' | 'methodsPath' | 'setModalProps'>>;
+interface IApiaApiHandlerState {
+    disabled: boolean;
+    isLoading: boolean;
+    isMultipart: boolean;
+    progress: number;
+    errors: Record<string, string>;
+    windowIndex: number;
+}
+declare const ApiaApiHandler: React.MemoExoticComponent<() => React.JSX.Element>;
+
+declare global {
+    interface Window {
+        SALT: string;
+        IV: string;
+        PASSPHRASE: string;
+        KEY_SIZE: number;
+        ITERATION_COUNT: string;
+    }
+}
+/**
+ * Permite cargar en forma asíncrona un modal que se encuentre dentro del
+ * directorio /api/modals
+ * */
+declare const getModal: (path: string) => React__default.LazyExoticComponent<React__default.ComponentType<TApiaApiField>>;
+
+export { ApiaApi, ApiaApiHandler, type IApiaApiRequestConfig, type TApiaApiAxiosResponse, type TApiaApiMethod, type TApiaApiResult, getFunction, getModal, makeApiaUrl };
 //# sourceMappingURL=index.d.ts.map