dsql-admin/dsql-app/package-shared/utils/data-fetching/method-crud.ts

import sqlGenerator from "../../functions/dsql/sql/sql-generator";
import {
    DsqlCrudQueryObject,
    DsqlMethodCrudParam,
    ServerQueryParam,
} from "../../types";
import deserializeQuery from "../deserialize-query";
import EJSON from "../ejson";
import numberfy from "../numberfy";
import dsqlCrud from "./crud";

export type APIDataCrudQuery = ServerQueryParam & {
    page?: number;
};

export type CRUDResponseObject<P extends any = any> = {
    success: boolean;
    payload?: P;
    msg?: string;
    error?: string;
    queryObject?: ReturnType<Awaited<typeof sqlGenerator>>;
};

export default async function dsqlMethodCrud<
    T extends { [key: string]: any } = { [key: string]: any },
    P extends { [key: string]: any } = { [key: string]: any }
>({
    method,
    tableName,
    addUser,
    user,
    extraData,
    transform,
    existingData,
    body,
    query,
    targetId,
    sanitize,
}: DsqlMethodCrudParam<T>): Promise<CRUDResponseObject<P>> {
    let result: CRUDResponseObject = {
        success: false,
    };

    try {
        let finalBody = body;
        let finalQuery = deserializeQuery(query as any) as
            | DsqlCrudQueryObject<T>
            | undefined;

        let LIMIT = 10;
        let PAGE = 1;
        let OFFSET = (PAGE - 1) * LIMIT;

        if (finalQuery) {
            Object.keys(finalQuery).forEach((key) => {
                const value = finalQuery[key];
                if (typeof value == "string" && value.match(/^\{|^\[/)) {
                    finalQuery[key] = EJSON.stringify(value);
                }
                if (value == "true") {
                    finalQuery[key] = true;
                }
                if (value == "false") {
                    finalQuery[key] = false;
                }
            });

            if (finalQuery.limit) LIMIT = numberfy(finalQuery.limit);
            if (finalQuery.page) PAGE = numberfy(finalQuery.page);
            OFFSET = (PAGE - 1) * LIMIT;
        }

        let finalData = finalBody
            ? ({
                  ...finalBody,
                  ...extraData,
              } as T)
            : undefined;

        if (finalData && user?.id && addUser) {
            finalData = {
                ...finalData,
                [addUser.field]: String(user.id),
            };
        }

        if (transform && finalData) {
            finalData = await transform({
                data: finalData,
                existingData: existingData,
                user,
                reqMethod: method,
            });
        }

        switch (method) {
            case "GET":
                const GET_RESULT = await dsqlCrud({
                    action: "get",
                    table: tableName,
                    query: finalQuery
                        ? ({
                              ...finalQuery,
                              query: {
                                  ...finalQuery.query,
                                  ...(user?.id && addUser
                                      ? {
                                            [addUser.field]: {
                                                value: String(user.id),
                                            },
                                        }
                                      : undefined),
                              },
                              limit: LIMIT,
                              offset: OFFSET,
                          } as any)
                        : undefined,
                    sanitize,
                });

                result = {
                    success: Boolean(GET_RESULT?.success),
                    payload: GET_RESULT?.payload,
                    msg: GET_RESULT?.msg,
                    error: GET_RESULT?.error,
                    queryObject: GET_RESULT?.queryObject,
                };
                break;

            case "POST":
                const POST_RESULT = await dsqlCrud({
                    action: "insert",
                    table: tableName,
                    data: finalData,
                    sanitize,
                });
                result = {
                    success: Boolean(POST_RESULT?.success),
                    payload: POST_RESULT?.payload,
                    msg: POST_RESULT?.msg,
                    error: POST_RESULT?.error,
                };
                break;

            case "PUT":
                const PUT_RESULT = await dsqlCrud({
                    action: "update",
                    table: tableName,
                    data: finalData,
                    targetId,
                    sanitize,
                });
                result = {
                    success: Boolean(PUT_RESULT?.success),
                    payload: PUT_RESULT?.payload,
                    msg: PUT_RESULT?.msg,
                    error: PUT_RESULT?.error,
                };
                break;
            case "DELETE":
                const DELETE_RESULT = await dsqlCrud({
                    action: "delete",
                    table: tableName,
                    targetId,
                    sanitize,
                });
                result = {
                    success: Boolean(DELETE_RESULT?.success),
                    payload: DELETE_RESULT?.payload,
                    msg: DELETE_RESULT?.msg,
                    error: DELETE_RESULT?.error,
                };
                break;

            default:
                break;
        }
        return result;
    } catch (error) {
        return result;
    }
}