swagger-typescript/lib/generateHook.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.generateHook = void 0;
const utils_1 = require("./utils");
const strings_1 = require("./strings");
const jsdoc_1 = require("./utilities/jsdoc");
const allowedPageParametersNames = ["page", "pageno", "pagenumber"];
function generateHook(apis, types, config) {
    var _a, _b;
    let code = strings_1.getHooksImports({
        hasInfinity: !!((_a = config.useInfiniteQuery) === null || _a === void 0 ? void 0 : _a.length),
    });
    try {
        apis = apis.sort(({ serviceName }, { serviceName: _serviceName }) => utils_1.isAscending(serviceName, _serviceName));
        const apisCode = apis.reduce((prev, { summary, deprecated, serviceName, queryParamsTypeName, pathParams, requestBody, headerParams, isQueryParamsNullable, isHeaderParamsNullable, responses, method, queryParameters, }) => {
            var _a, _b, _c;
            const hookName = `use${utils_1.toPascalCase(serviceName)}`;
            const hasPaging = (_a = config.useInfiniteQuery) === null || _a === void 0 ? void 0 : _a.find((name) => name.toLowerCase() === serviceName.toLowerCase() ||
                name.toLowerCase() === hookName.toLowerCase());
            const isGet = hasPaging ||
                method === "get" ||
                ((_b = config.useQuery) === null || _b === void 0 ? void 0 : _b.find((name) => name.toLowerCase() === serviceName.toLowerCase() ||
                    name.toLowerCase() === hookName.toLowerCase()));
            const getParamsString = (override) => ` ${pathParams.length ? `${pathParams.map(({ name }) => name)},` : ""}
          ${requestBody ? "requestBody," : ""}
          ${queryParamsTypeName
                ? hasPaging && override
                    ? `{
                  ..._param,
                  ...queryParams,
                },`
                    : "queryParams,"
                : ""}
          ${headerParams ? "headerParams," : ""}`;
            const TData = `${responses ? utils_1.getTsType(responses, config) : "any"}`;
            const TQueryFnData = `SwaggerResponse<${TData}>`;
            const TError = "RequestError | Error";
            const getQueryParamName = (name, nullable = isQueryParamsNullable, isPartial) => queryParamsTypeName
                ? `${utils_1.getParamString(name, !nullable, queryParamsTypeName, undefined, isPartial)},`
                : "";
            const TVariables = `${
            /** Path parameters */
            pathParams
                .map(({ name, required, schema, description }) => utils_1.getDefineParam(name, required, schema, config, description))
                .join(",")}${pathParams.length > 0 ? "," : ""}${
            /** Request Body */
            requestBody
                ? `${utils_1.getDefineParam("requestBody", true, requestBody, config)},`
                : ""}${
            /** Query parameters */
            getQueryParamName("queryParams")}${
            /** Header parameters */
            headerParams
                ? `${utils_1.getParamString("headerParams", !isHeaderParamsNullable, headerParams)},`
                : ""}`;
            const deps = `[${serviceName}.key,${pathParams.length ? `${pathParams.map(({ name }) => name)},` : ""}
            ${requestBody ? "requestBody," : ""}
            ${queryParamsTypeName ? "queryParams," : ""}
            ${headerParams ? "headerParams," : ""}]`;
            let result = prev +
                `
      ${jsdoc_1.getJsdoc({
                    description: summary,
                    deprecated: deprecated ? strings_1.DEPRECATED_WARM_MESSAGE : undefined,
                })}`;
            result += `export const ${hookName} =`;
            if (!isGet) {
                result += `<TExtra>`;
            }
            const params = [
                `${isGet ? TVariables : ""}`,
                `options?:${hasPaging
                    ? `UseInfiniteQueryOptions<${TQueryFnData}, ${TError}>`
                    : isGet
                        ? `InternalUseQueryOptions<${TData}>`
                        : `${TVariables
                            ? `InternalUseMutationOptions<${TData}, {${TVariables}}, TExtra>`
                            : `InternalUseMutationOptionsVoid<${TData}, TExtra>`}`},`,
                `${isGet ? `configOverride?:AxiosRequestConfig` : ""}`,
            ];
            result += ` (
           ${params.join("")}
           ) => {`;
            if (isGet) {
                result += `
          const { key, fun } = ${hookName}.info(${getParamsString()} configOverride);
          `;
                if (hasPaging) {
                    result += `const {
            data: { pages } = {},
            data,
            ...rest
          } = useInfiniteQuery(
            key,
            ({ pageParam = 1 }) =>
              fun({
                  ${(_c = queryParameters.find(({ name }) => allowedPageParametersNames.includes(name.toLowerCase()))) === null || _c === void 0 ? void 0 : _c.name}:pageParam,
              }),
            {
              getNextPageParam: (_lastPage, allPages) => allPages.length + 1,
              ...(options as any),
            },
          );
        
          const list = useMemo(() => paginationFlattenData(pages), [pages]);
          const total = getTotal(pages);

          const hasMore = useHasMore(pages, list, queryParams);
          
          return {...rest, data, list, hasMore, total}
          `;
                }
                else {
                    result += `return useQuery(
                key, 
                fun,
                options
               )`;
                }
            }
            else {
                result += `return useMutation((_o)=>{
            const {${getParamsString()} configOverride } = _o || {};

            return ${serviceName}(
                ${getParamsString()} configOverride,
              )
          },
          options
         )`;
            }
            result += `  
          }
        `;
            if (isGet) {
                result += `${hookName}.info = (${params
                    .filter((param) => !param.startsWith("options?:"))
                    .join("")}) => {
              return {
                key: ${deps} as QueryKey,
                fun: (${hasPaging ? getQueryParamName("_param", true, true) : ""}) =>
                ${serviceName}(
                  ${getParamsString(true)}
                  configOverride
                ),
              };
            };`;
                result += `${hookName}.prefetch = (
            client: QueryClient,
            ${params.join("")}) => {
                const { key, fun } = ${hookName}.info(${getParamsString()} configOverride);

                return client.getQueryData(key)
                ? Promise.resolve()
                : client.prefetchQuery(
                    key,
                    ()=>fun(),
                    options
                  );
              }`;
            }
            return result;
        }, "");
        code +=
            types
                .sort(({ name }, { name: _name }) => utils_1.isAscending(name, _name))
                .reduce((prev, { name: _name }) => {
                const name = utils_1.getSchemaName(_name);
                if (!utils_1.isMatchWholeWord(apisCode, name)) {
                    return prev;
                }
                return prev + ` ${name},`;
            }, "import {") + '}  from "./types"\n';
        code += strings_1.getHooksFunctions({
            hasInfinity: !!((_b = config.useInfiniteQuery) === null || _b === void 0 ? void 0 : _b.length),
        });
        code +=
            apis.reduce((prev, { serviceName }) => {
                return prev + ` ${serviceName},`;
            }, "import {") + '}  from "./services"\n';
        code += `
    type InternalMutationDefaultParams<TExtra> = {_extraVariables?:TExtra, configOverride?:AxiosRequestConfig}
    type InternalUseQueryOptions<TData> = UseQueryOptions<SwaggerResponse<TData>,RequestError | Error>;

    type InternalUseMutationOptions<TData, TRequest, TExtra> = UseMutationOptions<
      SwaggerResponse<TData>,
      RequestError | Error,
      TRequest & InternalMutationDefaultParams<TExtra>
    >;

    type InternalUseMutationOptionsVoid<
      TData,
      TExtra
    > = UseMutationOptions<
      SwaggerResponse<TData>,
      RequestError | Error,
      InternalMutationDefaultParams<TExtra> | void
    >;  
    `;
        code += apisCode;
        return code;
    }
    catch (error) {
        console.error(error);
        return "";
    }
}
exports.generateHook = generateHook;
//# sourceMappingURL=generateHook.js.map