Updates

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

@@ -0,0 +1,74 @@
+import get from "../../actions/get";
+import post from "../../actions/post";
+import sqlGenerator from "../../functions/dsql/sql/sql-generator";
+import { DsqlCrudParam, PostReturn } from "../../types";
+
+export default async function dsqlCrud<
+    T extends { [key: string]: any } = { [key: string]: any }
+>({
+    action,
+    data,
+    table,
+    targetId,
+    query,
+    sanitize,
+}: DsqlCrudParam<T>): Promise<
+    | (PostReturn & {
+          queryObject?: ReturnType<Awaited<typeof sqlGenerator>>;
+      })
+    | null
+> {
+    const finalData = sanitize ? sanitize(data) : data;
+    const finalId = targetId;
+    let queryObject: ReturnType<Awaited<typeof sqlGenerator>> | undefined;
+
+    switch (action) {
+        case "get":
+            queryObject = sqlGenerator({
+                tableName: table,
+                genObject: query,
+            });
+
+            const GET_RES = await get({
+                query: queryObject?.string || "",
+                queryValues: queryObject?.values || [],
+            });
+
+            return { ...GET_RES, queryObject };
+
+        case "insert":
+            return await post({
+                query: {
+                    action: "insert",
+                    table,
+                    data: finalData,
+                },
+            });
+
+        case "update":
+            delete data?.id;
+
+            return await post({
+                query: {
+                    action: "update",
+                    table,
+                    identifierColumnName: "id",
+                    identifierValue: String(finalId),
+                    data: finalData,
+                },
+            });
+
+        case "delete":
+            return await post({
+                query: {
+                    action: "delete",
+                    table,
+                    identifierColumnName: "id",
+                    identifierValue: String(finalId),
+                },
+            });
+
+        default:
+            return null;
+    }
+}

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

@@ -0,0 +1,182 @@
+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;
+    }
+}