Updates

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

@@ -0,0 +1,95 @@
+import get from "../../actions/get";
+import post from "../../actions/post";
+import sqlGenerator from "../../functions/dsql/sql/sql-generator";
+import {
+    PostReturn,
+    ServerQueryParam,
+    ServerQueryQueryObject,
+} from "../../types";
+import numberfy from "../numberfy";
+
+export const DsqlCrudActions = ["insert", "update", "delete", "get"] as const;
+
+export type CrudQueryObject<T extends object = { [key: string]: any }> =
+    ServerQueryParam & {
+        query: ServerQueryQueryObject<T>;
+    };
+
+export type CrudParam<T extends object = { [key: string]: any }> = {
+    action: (typeof DsqlCrudActions)[number];
+    table: string;
+    data?: T;
+    targetId?: string | number;
+    query?: CrudQueryObject<T>;
+    sanitize?: (data?: T) => T;
+};
+
+export default async function dsqlCrud<
+    T extends { [key: string]: any } = { [key: string]: any }
+>({
+    action,
+    data,
+    table,
+    targetId,
+    query,
+    sanitize,
+}: CrudParam<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;
+    }
+}

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

@@ -0,0 +1,180 @@
+import { DATASQUIREL_LoggedInUser, ServerQueryParam } from "../../types";
+import EJSON from "../ejson";
+import dsqlCrud from "./crud";
+
+export const DataCrudRequestMethods = ["GET", "POST", "PUT", "DELETE"] as const;
+
+export type APIDataCrudQuery = ServerQueryParam & {
+    page?: number;
+};
+
+export type CRUDResponseObject<P extends any = any> = {
+    success: boolean;
+    payload?: P;
+    msg?: string;
+    error?: string;
+};
+
+export type ApiDataCrudParam<
+    T extends { [key: string]: any } = { [key: string]: any }
+> = {
+    method: (typeof DataCrudRequestMethods)[number];
+    body?: T;
+    query?: string | T;
+    tableName: string;
+    addUser?: {
+        field: string;
+    };
+    user?: DATASQUIREL_LoggedInUser;
+    extraData?: T;
+    transform?: ({
+        data,
+        existingData,
+        user,
+    }: {
+        user?: DATASQUIREL_LoggedInUser;
+        data: T;
+        existingData?: T;
+        reqMethod: (typeof DataCrudRequestMethods)[number];
+    }) => Promise<T>;
+    existingData?: T;
+};
+
+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,
+}: ApiDataCrudParam<T>): Promise<CRUDResponseObject<P>> {
+    let result: CRUDResponseObject = {
+        success: false,
+    };
+
+    try {
+        let finalBody = body as any;
+        let finalQuery = query as any;
+
+        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;
+            }
+        });
+
+        const LIMIT = finalQuery.limit || 10;
+        const PAGE = finalQuery.page || 1;
+        const OFFSET = (PAGE - 1) * LIMIT;
+
+        let finalData = {
+            ...finalBody.data,
+            ...extraData,
+        } as T;
+
+        if (user && addUser) {
+            finalData = {
+                ...finalData,
+                [addUser.field]: String(user.id),
+            };
+        }
+
+        if (transform) {
+            finalData = await transform({
+                data: finalData,
+                existingData: existingData,
+                user,
+                reqMethod: method as (typeof DataCrudRequestMethods)[number],
+            });
+        }
+
+        switch (method) {
+            case "GET":
+                const GET_RESULT = await dsqlCrud({
+                    action: "get",
+                    table: tableName,
+                    query: {
+                        ...finalQuery,
+                        query: {
+                            ...finalQuery.query,
+                            user_id: user
+                                ? {
+                                      value: String(user.id),
+                                  }
+                                : undefined,
+                        },
+                        limit: LIMIT,
+                        offset: OFFSET || undefined,
+                    },
+                });
+
+                result = {
+                    success: Boolean(GET_RESULT?.success),
+                    payload: GET_RESULT?.payload,
+                    msg: GET_RESULT?.msg,
+                    error: GET_RESULT?.error,
+                };
+                break;
+
+            case "POST":
+                const POST_RESULT = await dsqlCrud({
+                    action: "insert",
+                    table: tableName,
+                    data: finalData,
+                });
+                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: finalBody.data.id,
+                });
+                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: finalBody.data.id,
+                });
+                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;
+    }
+}