First Commit

src/pages/api/admin/crud/(functions)/default-checks.ts

@@ -0,0 +1,28 @@
+import checkUserAccess from "@/src/functions/backend/auth/check-user-access";
+import type { AdminCrudAPIParams } from "@/src/types";
+import type { APIResponseObject } from "@moduletrace/bunext/types";
+
+export default async function ({
+    user,
+    user_types,
+}: AdminCrudAPIParams): Promise<APIResponseObject> {
+    if (!user?.id) {
+        return {
+            success: false,
+            msg: `No user passed`,
+        };
+    }
+
+    const is_super_admin = checkUserAccess({ user_types });
+
+    if (!is_super_admin.success) {
+        return {
+            success: false,
+            msg: `Unauthorized`,
+        };
+    }
+
+    return {
+        success: true,
+    };
+}

src/pages/api/admin/crud/(functions)/delete/checks.ts

@@ -0,0 +1,28 @@
+import _ from "lodash";
+import defaultChecks from "../default-checks";
+import type { AdminCrudAPIParams } from "@/src/types";
+import type { APIResponseObject } from "@moduletrace/bunext/types";
+import checkUserAccess from "@/src/functions/backend/auth/check-user-access";
+
+export default async function (
+    params: AdminCrudAPIParams,
+): Promise<APIResponseObject> {
+    const { table, user, user_types, body, id, query } = params;
+
+    const default_check = await defaultChecks(params);
+    const is_super_admin = checkUserAccess({ user_types }).success;
+
+    if (!default_check.success) {
+        return default_check;
+    }
+
+    if (!is_super_admin) {
+        return {
+            success: false,
+        };
+    }
+
+    return {
+        success: true,
+    };
+}

src/pages/api/admin/crud/(functions)/delete/index.ts

@@ -0,0 +1,28 @@
+import _ from "lodash";
+import checks from "./checks";
+import type { AdminCrudAPIParams } from "@/src/types";
+import type { APIResponseObject } from "@moduletrace/bunext/types";
+import BunSQLite from "@moduletrace/bun-sqlite";
+
+export default async function (
+    params: AdminCrudAPIParams,
+): Promise<APIResponseObject> {
+    const { table, body, id, query } = params;
+
+    const check = await checks(params);
+
+    if (!check?.success) {
+        return {
+            success: false,
+            msg: `Delete Unauthorized`,
+        };
+    }
+
+    const res = await BunSQLite.delete({
+        table,
+        query: _.merge(query?.sql_query, body?.sql_query),
+        targetId: id,
+    });
+
+    return res;
+}

src/pages/api/admin/crud/(functions)/get/checks.ts

@@ -0,0 +1,20 @@
+import _ from "lodash";
+import defaultChecks from "../default-checks";
+import type { AdminCrudAPIParams } from "@/src/types";
+import type { APIResponseObject } from "@moduletrace/bunext/types";
+
+export default async function (
+    params: AdminCrudAPIParams,
+): Promise<APIResponseObject> {
+    const { table, user, user_types, body, id, query } = params;
+
+    const default_check = await defaultChecks(params);
+
+    if (!default_check.success) {
+        return default_check;
+    }
+
+    return {
+        success: true,
+    };
+}

src/pages/api/admin/crud/(functions)/get/index.ts

@@ -0,0 +1,31 @@
+import _ from "lodash";
+import checks from "./checks";
+import type { AdminCrudAPIParams } from "@/src/types";
+import type { APIResponseObject } from "@moduletrace/bunext/types";
+import BunSQLite from "@moduletrace/bun-sqlite";
+
+export default async function (
+    params: AdminCrudAPIParams,
+): Promise<APIResponseObject> {
+    const { table, body, id, query } = params;
+
+    const check = await checks(params);
+
+    if (!check?.success) {
+        return {
+            success: false,
+            msg: `Select Unauthorized`,
+        };
+    }
+
+    let final_sql_query = _.merge(query?.sql_query, body?.sql_query);
+
+    const res = await BunSQLite.select({
+        table,
+        query: final_sql_query,
+        targetId: id,
+        count: query?.count || body?.count,
+    });
+
+    return res;
+}

src/pages/api/admin/crud/(functions)/post/checks.ts

@@ -0,0 +1,18 @@
+import type { AdminCrudAPIParams } from "@/src/types";
+import type { APIResponseObject } from "@moduletrace/bunext/types";
+import _ from "lodash";
+import defaultChecks from "../default-checks";
+
+export default async function (
+    params: AdminCrudAPIParams,
+): Promise<APIResponseObject> {
+    const default_check = await defaultChecks(params);
+
+    if (!default_check.success) {
+        return default_check;
+    }
+
+    return {
+        success: true,
+    };
+}

src/pages/api/admin/crud/(functions)/post/index.ts

@@ -0,0 +1,37 @@
+import _ from "lodash";
+import checks from "./checks";
+import type { AdminCrudAPIParams } from "@/src/types";
+import type { APIResponseObject } from "@moduletrace/bunext/types";
+import BunSQLite from "@moduletrace/bun-sqlite";
+
+export default async function (
+    params: AdminCrudAPIParams,
+): Promise<APIResponseObject> {
+    const { table, body } = params;
+
+    const check = await checks(params);
+
+    if (!check?.success) {
+        return {
+            success: false,
+            msg: `Insert Unauthorized`,
+        };
+    }
+
+    if (!body?.insert_data) {
+        return {
+            success: false,
+            msg: `No data to insert`,
+        };
+    }
+
+    let final_insert_data = [...body.insert_data];
+
+    const res = await BunSQLite.insert({
+        table,
+        data: final_insert_data,
+        update_on_duplicate: body.update_on_duplicate,
+    });
+
+    return res;
+}

src/pages/api/admin/crud/(functions)/put/checks.ts

@@ -0,0 +1,30 @@
+import _ from "lodash";
+import defaultChecks from "../default-checks";
+import type { AdminCrudAPIParams } from "@/src/types";
+import type { APIResponseObject } from "@moduletrace/bunext/types";
+import checkUserAccess from "@/src/functions/backend/auth/check-user-access";
+
+export default async function (
+    params: AdminCrudAPIParams,
+): Promise<APIResponseObject> {
+    const { user_types } = params;
+
+    const default_check = await defaultChecks(params);
+
+    if (!default_check.success) {
+        return default_check;
+    }
+
+    const is_admin = checkUserAccess({
+        user_types,
+        includes: ["admin"],
+    });
+
+    if (!is_admin.success) {
+        return is_admin;
+    }
+
+    return {
+        success: true,
+    };
+}

src/pages/api/admin/crud/(functions)/put/index.ts

@@ -0,0 +1,36 @@
+import _ from "lodash";
+import checks from "./checks";
+import type { AdminCrudAPIParams } from "@/src/types";
+import type { APIResponseObject } from "@moduletrace/bunext/types";
+import BunSQLite from "@moduletrace/bun-sqlite";
+
+export default async function (
+    params: AdminCrudAPIParams,
+): Promise<APIResponseObject> {
+    const { table, body, id, query } = params;
+
+    const check = await checks(params);
+
+    if (!check?.success) {
+        return {
+            success: false,
+            msg: `Update Unauthorized`,
+        };
+    }
+
+    if (!body?.update_data) {
+        return {
+            success: false,
+            msg: `No data to update`,
+        };
+    }
+
+    const res = await BunSQLite.update({
+        table,
+        data: body.update_data,
+        query: _.merge(query?.sql_query, body?.sql_query),
+        targetId: id,
+    });
+
+    return res;
+}

src/pages/api/admin/crud/(tables)/media/del.ts

@@ -0,0 +1,72 @@
+import _ from "lodash";
+import type { AdminCrudAPIParams, TableType } from "@/src/types";
+import type { APIResponseObject } from "@moduletrace/bunext/types";
+import checkUserAccess from "@/src/functions/backend/auth/check-user-access";
+import type {
+    BUN_SQLITE_WGUI_ALL_TYPEDEFS,
+    BUN_SQLITE_WGUI_MEDIA,
+} from "@/db/types/db";
+import BunSQLite from "@moduletrace/bun-sqlite";
+import { rmSync } from "fs";
+import type { ServerQueryParam } from "@moduletrace/bun-sqlite/dist/types";
+
+export default async function (
+    params: AdminCrudAPIParams,
+): Promise<APIResponseObject> {
+    const { user, user_types, body, id } = params;
+
+    const can_delete_media = checkUserAccess({
+        user_types,
+        includes: ["admin"],
+    });
+
+    if (!can_delete_media.success) {
+        return {
+            success: false,
+            msg: `Can't delete media`,
+        };
+    }
+
+    let query = _.merge<
+        ServerQueryParam<BUN_SQLITE_WGUI_ALL_TYPEDEFS>,
+        ServerQueryParam<BUN_SQLITE_WGUI_ALL_TYPEDEFS>
+    >(body?.sql_query || {}, {});
+
+    const media_to_delete = await BunSQLite.select<
+        BUN_SQLITE_WGUI_MEDIA,
+        TableType
+    >({
+        table: "media",
+        query,
+        targetId: id,
+    });
+
+    if (!media_to_delete.payload) {
+        return {
+            success: false,
+            msg: `No Media to Delete.`,
+        };
+    }
+
+    for (let i = 0; i < media_to_delete.payload.length; i++) {
+        const media = media_to_delete.payload[i];
+        if (!media?.id) continue;
+
+        if (media.media_write_path) {
+            rmSync(media.media_write_path);
+        }
+
+        if (media.media_thumbnail_write_path) {
+            rmSync(media.media_thumbnail_write_path);
+        }
+
+        await BunSQLite.delete<BUN_SQLITE_WGUI_MEDIA, TableType>({
+            table: "media",
+            targetId: media.id,
+        });
+    }
+
+    return {
+        success: true,
+    };
+}

src/pages/api/admin/crud/(tables)/media/get.ts

@@ -0,0 +1,34 @@
+import checkUserAccess from "@/src/functions/backend/auth/check-user-access";
+import grabMedia from "@/src/functions/backend/db/media/grab-media";
+import type { AdminCrudAPIParams } from "@/src/types";
+import BunSQLite from "@moduletrace/bun-sqlite";
+import type { APIResponseObject } from "@moduletrace/bunext/types";
+import _ from "lodash";
+
+export default async function (
+    params: AdminCrudAPIParams,
+): Promise<APIResponseObject> {
+    const { table, user_types, body, id, query, user } = params;
+
+    let final_sql_query = _.merge(query?.sql_query, body?.sql_query) || {};
+
+    delete final_sql_query.join;
+
+    const can_user_see_all_media = checkUserAccess({
+        user_types,
+        includes: ["admin"],
+    });
+
+    if (!can_user_see_all_media.success) {
+        final_sql_query.query = {
+            ...final_sql_query.query,
+            user_id: {
+                value: user.id,
+            },
+        };
+    }
+
+    const GET = await grabMedia({ query, user });
+
+    return GET;
+}

src/pages/api/admin/crud/(tables)/media/index.ts

@@ -0,0 +1,29 @@
+import type { AdminCrudAPIParams } from "@/src/types";
+import type { APIResponseObject } from "@moduletrace/bunext/types";
+import _ from "lodash";
+import get from "./get";
+import post from "./post";
+import put from "./put";
+import del from "./del";
+
+export default async function (
+    params: AdminCrudAPIParams,
+): Promise<APIResponseObject> {
+    const { req, query } = params;
+
+    switch (req.method) {
+        case "GET":
+            return await get(params);
+        case "POST":
+            return await post(params);
+        case "PUT":
+            return await put(params);
+        case "DELETE":
+            return await del(params);
+
+        default:
+            return {
+                success: false,
+            };
+    }
+}

src/pages/api/admin/crud/(tables)/media/post.ts

@@ -0,0 +1,36 @@
+import type { BUN_SQLITE_WGUI_MEDIA } from "@/db/types/db";
+import checkUserAccess from "@/src/functions/backend/auth/check-user-access";
+import type { AdminCrudAPIParams } from "@/src/types";
+import BunSQLite from "@moduletrace/bun-sqlite";
+import type { APIResponseObject } from "@moduletrace/bunext/types";
+import _ from "lodash";
+
+export default async function (
+    params: AdminCrudAPIParams,
+): Promise<APIResponseObject> {
+    const { table, body, user_types, user } = params;
+
+    let final_insert_data: BUN_SQLITE_WGUI_MEDIA[] = [
+        ...(body?.insert_data || []),
+    ].map((d) => ({ ...d, user_id: user.id }));
+
+    const is_user_allowed_to_post_any = checkUserAccess({
+        includes: ["admin"],
+        user_types,
+    });
+
+    if (!is_user_allowed_to_post_any.success) {
+        final_insert_data = final_insert_data.map((fid) => ({
+            ...fid,
+            user_id: user.id,
+        }));
+    }
+
+    const POST = await BunSQLite.insert({
+        table,
+        data: final_insert_data,
+        update_on_duplicate: body?.update_on_duplicate,
+    });
+
+    return POST;
+}

src/pages/api/admin/crud/(tables)/media/put.ts

@@ -0,0 +1,40 @@
+import checkUserAccess from "@/src/functions/backend/auth/check-user-access";
+import type { AdminCrudAPIParams } from "@/src/types";
+import BunSQLite from "@moduletrace/bun-sqlite";
+import type { APIResponseObject } from "@moduletrace/bunext/types";
+import _ from "lodash";
+
+export default async function (
+    params: AdminCrudAPIParams,
+): Promise<APIResponseObject> {
+    const { table, body, user_types, id, query, user } = params;
+
+    if (!body?.update_data) {
+        return {
+            success: false,
+            msg: `No Update Data`,
+        };
+    }
+
+    const is_user_allowed_to_put = checkUserAccess({
+        includes: ["admin"],
+        user_types,
+    });
+
+    let final_sql_query = _.merge(query?.sql_query, body?.sql_query) || {};
+    let targetId = id;
+
+    if (!is_user_allowed_to_put.success) {
+        final_sql_query = {};
+        targetId = user.id;
+    }
+
+    const PUT = await BunSQLite.update({
+        table,
+        data: body?.update_data,
+        targetId,
+        query: final_sql_query,
+    });
+
+    return PUT;
+}

src/pages/api/admin/crud/(tables)/user_types/del.ts

@@ -0,0 +1,87 @@
+import type { BUN_SQLITE_WGUI_ALL_TYPEDEFS } from "@/db/types/db";
+import {
+    RolesAdminCantUpdate,
+    SuperAdminOnlyEditableUserTypes,
+    UneditableUserTypes,
+} from "@/src/dict/user-types-dict";
+import checkUserAccess from "@/src/functions/backend/auth/check-user-access";
+import type { AdminCrudAPIParams, UserType } from "@/src/types";
+import BunSQLite from "@moduletrace/bun-sqlite";
+import type { APIResponseObject } from "@moduletrace/bunext/types";
+import _ from "lodash";
+
+export default async function (
+    params: AdminCrudAPIParams,
+): Promise<APIResponseObject> {
+    const { table, user_types, body, id, query } = params;
+
+    let final_sql_query = _.merge(query?.sql_query, body?.sql_query) || {};
+
+    const records_to_delete =
+        await BunSQLite.select<BUN_SQLITE_WGUI_ALL_TYPEDEFS>({
+            table,
+            query: final_sql_query,
+            targetId: id,
+        });
+
+    if (!records_to_delete.payload?.[0]) {
+        return {
+            success: false,
+            msg: `No Records to Delete`,
+        };
+    }
+
+    const is_user_super_admin = checkUserAccess({
+        user_types,
+    });
+
+    const admin_includes: UserType[] = ["admin"];
+
+    const can_delete_user_type = checkUserAccess({
+        user_types,
+        includes: admin_includes,
+    });
+
+    const is_user_admin = Boolean(
+        user_types.find(
+            (ut) => ut.user_type && admin_includes.includes(ut.user_type),
+        ),
+    );
+
+    if (!can_delete_user_type.success) {
+        return can_delete_user_type;
+    }
+
+    const ignored_user_types = [...UneditableUserTypes] as UserType[];
+
+    if (!is_user_super_admin.success) {
+        ignored_user_types.push(...SuperAdminOnlyEditableUserTypes);
+    }
+
+    const user_types_to_delete = records_to_delete.payload.filter(
+        (rec) => !ignored_user_types.includes(rec.user_type as any),
+    );
+
+    for (let i = 0; i < user_types_to_delete.length; i++) {
+        const user_type_to_delete = user_types_to_delete[i];
+
+        if (!user_type_to_delete?.id) continue;
+
+        if (
+            is_user_admin &&
+            user_type_to_delete.user_type &&
+            RolesAdminCantUpdate.includes(user_type_to_delete.user_type)
+        ) {
+            continue;
+        }
+
+        await BunSQLite.delete({
+            table,
+            targetId: user_type_to_delete.id,
+        });
+    }
+
+    return {
+        success: true,
+    };
+}

src/pages/api/admin/crud/(tables)/user_types/get.ts

@@ -0,0 +1,38 @@
+import checkUserAccess from "@/src/functions/backend/auth/check-user-access";
+import type { AdminCrudAPIParams } from "@/src/types";
+import BunSQLite from "@moduletrace/bun-sqlite";
+import type { APIResponseObject } from "@moduletrace/bunext/types";
+import _ from "lodash";
+
+export default async function (
+    params: AdminCrudAPIParams,
+): Promise<APIResponseObject> {
+    const { table, user_types, body, id, query, user } = params;
+
+    let final_sql_query = _.merge(query?.sql_query, body?.sql_query) || {};
+
+    delete final_sql_query.join;
+
+    const can_user_see_all_user_types = checkUserAccess({
+        user_types,
+        includes: ["admin"],
+    });
+
+    if (!can_user_see_all_user_types.success) {
+        final_sql_query.query = {
+            ...final_sql_query.query,
+            user_id: {
+                value: user.id,
+            },
+        };
+    }
+
+    const GET = await BunSQLite.select({
+        table,
+        query: final_sql_query,
+        targetId: id,
+        count: query?.count || body?.count,
+    });
+
+    return GET;
+}

src/pages/api/admin/crud/(tables)/user_types/index.ts

@@ -0,0 +1,29 @@
+import type { AdminCrudAPIParams } from "@/src/types";
+import type { APIResponseObject } from "@moduletrace/bunext/types";
+import _ from "lodash";
+import get from "./get";
+import post from "./post";
+import put from "./put";
+import del from "./del";
+
+export default async function (
+    params: AdminCrudAPIParams,
+): Promise<APIResponseObject> {
+    const { req, query } = params;
+
+    switch (req.method) {
+        case "GET":
+            return await get(params);
+        case "POST":
+            return await post(params);
+        case "PUT":
+            return await put(params);
+        case "DELETE":
+            return await del(params);
+
+        default:
+            return {
+                success: false,
+            };
+    }
+}

src/pages/api/admin/crud/(tables)/user_types/post.ts

@@ -0,0 +1,61 @@
+import {
+    RolesAdminCantUpdate,
+    SuperAdminOnlyEditableUserTypes,
+    UneditableUserTypes,
+} from "@/src/dict/user-types-dict";
+import checkUserAccess from "@/src/functions/backend/auth/check-user-access";
+import type { AdminCrudAPIParams, UserType } from "@/src/types";
+import BunSQLite from "@moduletrace/bun-sqlite";
+import type { APIResponseObject } from "@moduletrace/bunext/types";
+import _ from "lodash";
+
+export default async function (
+    params: AdminCrudAPIParams,
+): Promise<APIResponseObject> {
+    const { table, body, user_types } = params;
+
+    const is_user_super_admin = checkUserAccess({
+        user_types,
+    });
+
+    const ignored_user_types = [...UneditableUserTypes] as UserType[];
+
+    if (!is_user_super_admin.success) {
+        ignored_user_types.push(...SuperAdminOnlyEditableUserTypes);
+    }
+
+    let final_insert_data = [...(body?.insert_data || [])].filter(
+        (i) => !ignored_user_types.includes(i.user_type as any),
+    );
+
+    const admin_includes: UserType[] = ["admin"];
+
+    const is_user_allowed_to_post = checkUserAccess({
+        includes: admin_includes,
+        user_types,
+    });
+
+    if (!is_user_allowed_to_post.success) {
+        return is_user_allowed_to_post;
+    }
+
+    const is_user_admin = Boolean(
+        user_types.find(
+            (ut) => ut.user_type && admin_includes.includes(ut.user_type),
+        ),
+    );
+
+    if (is_user_admin) {
+        final_insert_data = final_insert_data.filter(
+            (d) => d.user_type && !RolesAdminCantUpdate.includes(d.user_type),
+        );
+    }
+
+    const POST = await BunSQLite.insert({
+        table,
+        data: final_insert_data,
+        update_on_duplicate: body?.update_on_duplicate,
+    });
+
+    return POST;
+}

src/pages/api/admin/crud/(tables)/user_types/put.ts

@@ -0,0 +1,14 @@
+import type { AdminCrudAPIParams } from "@/src/types";
+import type { APIResponseObject } from "@moduletrace/bunext/types";
+import _ from "lodash";
+
+export default async function (
+    params: AdminCrudAPIParams,
+): Promise<APIResponseObject> {
+    const { table, body, user_types, id, query } = params;
+
+    return {
+        success: false,
+        msg: `Can't update user_type. Can only delete and insert.`,
+    };
+}

src/pages/api/admin/crud/(tables)/users/get.ts

@@ -0,0 +1,60 @@
+import type { BUN_SQLITE_WGUI_ALL_TYPEDEFS } from "@/db/types/db";
+import checkUserAccess from "@/src/functions/backend/auth/check-user-access";
+import checkAllowedJoins from "@/src/functions/backend/db/check-allowed-joins";
+import grabUsers from "@/src/functions/backend/db/users/grab-users";
+import type { AdminCrudAPIParams, ApiReqParams, TableType } from "@/src/types";
+import BunSQLite from "@moduletrace/bun-sqlite";
+import type { APIResponseObject } from "@moduletrace/bunext/types";
+import _ from "lodash";
+
+export default async function (
+    params: AdminCrudAPIParams,
+): Promise<APIResponseObject> {
+    const { req, table, user_types, body, id, query, user } = params;
+
+    let final_sql_query = _.merge(query?.sql_query, body?.sql_query) || {};
+    let final_query =
+        _.merge<
+            ApiReqParams<BUN_SQLITE_WGUI_ALL_TYPEDEFS>,
+            ApiReqParams<BUN_SQLITE_WGUI_ALL_TYPEDEFS>
+        >(query || {}, { sql_query: final_sql_query }) || {};
+
+    const allowed_joins: TableType[] = ["user_types", "media"];
+
+    const check_allowed_joins = checkAllowedJoins({
+        joins: allowed_joins,
+        query: final_sql_query,
+    });
+
+    if (!check_allowed_joins.success) {
+        return check_allowed_joins;
+    }
+
+    const can_user_see_all_users = checkUserAccess({
+        user_types,
+        includes: ["admin"],
+    });
+
+    if (!can_user_see_all_users.success) {
+        final_sql_query.query = {
+            ...final_sql_query.query,
+            user_id: {
+                value: user.id,
+            },
+        };
+    }
+
+    // const GET = await BunSQLite.select({
+    //     table,
+    //     query: final_sql_query,
+    //     targetId: id,
+    //     count: query?.count || body?.count,
+    // });
+
+    const GET = await grabUsers({
+        query: final_query,
+        user_id: id,
+    });
+
+    return GET;
+}

src/pages/api/admin/crud/(tables)/users/index.ts

@@ -0,0 +1,31 @@
+import type { AdminCrudAPIParams } from "@/src/types";
+import type { APIResponseObject } from "@moduletrace/bunext/types";
+import _ from "lodash";
+import get from "./get";
+import post from "./post";
+import put from "./put";
+
+export default async function (
+    params: AdminCrudAPIParams,
+): Promise<APIResponseObject> {
+    const { req } = params;
+
+    switch (req.method) {
+        case "GET":
+            return await get(params);
+        case "POST":
+            return await post(params);
+        case "PUT":
+            return await put(params);
+        case "DELETE":
+            return {
+                success: false,
+                msg: `Can't delete any user`,
+            };
+
+        default:
+            return {
+                success: false,
+            };
+    }
+}

src/pages/api/admin/crud/(tables)/users/post.ts

@@ -0,0 +1,30 @@
+import checkUserAccess from "@/src/functions/backend/auth/check-user-access";
+import grabUsers from "@/src/functions/backend/db/users/grab-users";
+import type { AdminCrudAPIParams } from "@/src/types";
+import BunSQLite from "@moduletrace/bun-sqlite";
+import type { APIResponseObject } from "@moduletrace/bunext/types";
+import _ from "lodash";
+
+export default async function (
+    params: AdminCrudAPIParams,
+): Promise<APIResponseObject> {
+    const { table, body, user_types } = params;
+
+    let final_insert_data = [...(body?.insert_data || [])];
+
+    const is_user_allowed_to_post = checkUserAccess({
+        user_types,
+    });
+
+    if (!is_user_allowed_to_post.success) {
+        return is_user_allowed_to_post;
+    }
+
+    const POST = await BunSQLite.insert({
+        table,
+        data: final_insert_data,
+        update_on_duplicate: body?.update_on_duplicate,
+    });
+
+    return POST;
+}

src/pages/api/admin/crud/(tables)/users/put.ts

@@ -0,0 +1,41 @@
+import checkUserAccess from "@/src/functions/backend/auth/check-user-access";
+import type { AdminCrudAPIParams } from "@/src/types";
+import BunSQLite from "@moduletrace/bun-sqlite";
+import type { APIResponseObject } from "@moduletrace/bunext/types";
+import _ from "lodash";
+
+export default async function (
+    params: AdminCrudAPIParams,
+): Promise<APIResponseObject> {
+    const { table, body, user_types, id, query, user } = params;
+
+    let final_sql_query = _.merge(query?.sql_query, body?.sql_query) || {};
+
+    if (!body?.update_data) {
+        return {
+            success: false,
+            msg: `No Update Data`,
+        };
+    }
+
+    const is_user_allowed_to_update = checkUserAccess({
+        includes: ["admin"],
+        user_types,
+    });
+
+    let targetId = id;
+
+    if (!is_user_allowed_to_update.success) {
+        final_sql_query = {};
+        targetId = user.id;
+    }
+
+    const PUT = await BunSQLite.update({
+        table,
+        data: body.update_data,
+        targetId,
+        query: final_sql_query,
+    });
+
+    return PUT;
+}

src/pages/api/admin/crud/(utils)/check-allowed-join.ts

@@ -0,0 +1,14 @@
+import type { TableType } from "@/src/types";
+import type { APIResponseObject } from "@moduletrace/bunext/types";
+
+type Params = {
+    allowed_joins: TableType[];
+};
+
+export default function checkAllowedJoin({
+    allowed_joins,
+}: Params): APIResponseObject {
+    return {
+        success: true,
+    };
+}

src/pages/api/admin/crud/[[...paths]].ts

@@ -0,0 +1,108 @@
+import _ from "lodash";
+import users from "./(tables)/users";
+import userTypes from "./(tables)/user_types";
+import media from "./(tables)/media";
+import get from "./(functions)/get";
+import put from "./(functions)/put";
+import del from "./(functions)/delete";
+import post from "./(functions)/post";
+import type {
+    APIResponseObject,
+    BunextAPIRouteHandler,
+} from "@moduletrace/bunext/types";
+import type { AdminCrudAPIParams, ApiReqParams, TableType } from "@/src/types";
+import userAuth from "@/src/functions/backend/auth/user-auth";
+import checkUserAccess from "@/src/functions/backend/auth/check-user-access";
+
+export const handler: BunextAPIRouteHandler<APIResponseObject> = async (
+    params,
+) => {
+    const req = params.req;
+    const body = params.body as ApiReqParams;
+    const query = params.query as ApiReqParams;
+
+    const { user, user_types } = await userAuth({ req });
+
+    if (!user?.logged_in_status) {
+        return {
+            success: false,
+            msg: `Unauthorized`,
+            logoutUser: true,
+        };
+    }
+
+    if (!user_types?.[0]) {
+        return {
+            success: false,
+            msg: `User types not found`,
+            logoutUser: true,
+        };
+    }
+
+    try {
+        if (
+            user_types.find((ty) => ty.user_type == "read_only") &&
+            !req.method.match(/get/)
+        ) {
+            throw new Error(`This user can only read records.`);
+        }
+
+        const [table, id] = params.query.paths.split("/") as [
+            TableType,
+            string | number,
+        ];
+
+        const crud_params: AdminCrudAPIParams = {
+            table,
+            id,
+            user: user || undefined,
+            user_types: user_types || [],
+            body,
+            query,
+            req,
+        };
+
+        switch (table) {
+            case "users":
+                return await users(crud_params);
+            case "user_types":
+                return await userTypes(crud_params);
+            case "media":
+                return await media(crud_params);
+
+            default:
+                break;
+        }
+
+        const is_super_admin = checkUserAccess({ user_types });
+
+        if (!is_super_admin.success) {
+            return {
+                success: false,
+                msg: `Unauthorized`,
+            };
+        }
+
+        switch (req.method) {
+            case "GET":
+                return await get(crud_params);
+            case "POST":
+                return await post(crud_params);
+            case "PUT":
+                return await put(crud_params);
+            case "DELETE":
+                return await del(crud_params);
+
+            default:
+                return {
+                    success: false,
+                    msg: `Unhandled`,
+                };
+        }
+    } catch (error: any) {
+        return {
+            success: false,
+            msg: error.message,
+        };
+    }
+};

src/pages/api/admin/delete-media.ts

@@ -0,0 +1,58 @@
+import _ from "lodash";
+import userAuth from "@/src/functions/backend/auth/user-auth";
+import type { ApiReqParams } from "@/src/types";
+import type {
+    APIResponseObject,
+    BunextAPIRouteHandler,
+} from "@moduletrace/bunext/types";
+import deleteMedia from "@/src/functions/backend/db/media/delete-media";
+import checkUserAccess from "@/src/functions/backend/auth/check-user-access";
+
+export const handler: BunextAPIRouteHandler<APIResponseObject> = async (
+    params,
+) => {
+    const req = params.req;
+    const body = params.body as ApiReqParams;
+
+    if (req.method !== "DELETE") {
+        return {
+            success: false,
+        };
+    }
+
+    const { user, user_types } = await userAuth({ req });
+
+    if (!user?.logged_in_status) {
+        return {
+            success: false,
+            msg: `Unauthorized`,
+            logoutUser: true,
+        };
+    }
+
+    try {
+        const { id, ids, media_paradigm, user_id } = body;
+
+        const can_delete_all_media = checkUserAccess({
+            includes: ["admin", "board_member"],
+            user_types,
+        });
+
+        if (user_id && user.id !== user_id && !can_delete_all_media.success) {
+            throw new Error(`Operation not allowed!`);
+        }
+
+        return await deleteMedia({
+            id,
+            ids,
+            media_paradigm,
+            user_id,
+            can_delete_all_media: can_delete_all_media.success,
+        });
+    } catch (error: any) {
+        return {
+            success: false,
+            msg: `API Error: ${error.message}`,
+        };
+    }
+};

src/pages/api/admin/grab-users.ts

@@ -0,0 +1,48 @@
+import checkUserAccess from "@/src/functions/backend/auth/check-user-access";
+import userAuth from "@/src/functions/backend/auth/user-auth";
+import grabUsers from "@/src/functions/backend/db/users/grab-users";
+import type {
+    APIResponseObject,
+    BunextAPIRouteHandler,
+} from "@moduletrace/bunext/types";
+import _ from "lodash";
+
+export const handler: BunextAPIRouteHandler<APIResponseObject> = async ({
+    req,
+    query,
+}) => {
+    const { user, user_types } = await userAuth({ req });
+
+    if (!user?.logged_in_status) {
+        return {
+            success: false,
+            msg: `Unauthorized`,
+        };
+    }
+
+    try {
+        const is_admin = checkUserAccess({
+            user_types,
+            includes: ["admin"],
+        });
+
+        if (
+            !is_admin.success &&
+            (!query?.user_id || query.user_id !== user.id)
+        ) {
+            return {
+                success: false,
+                msg: `Unauthorized`,
+            };
+        }
+
+        return await grabUsers({
+            query,
+        });
+    } catch (error: any) {
+        return {
+            success: false,
+            msg: error.message,
+        };
+    }
+};

src/pages/api/admin/upload-media.ts

@@ -0,0 +1,87 @@
+import twuiNumberfy from "@/src/components/twui/utils/numberfy";
+import loginUser from "@/src/functions/backend/auth/login-user";
+import userAuth from "@/src/functions/backend/auth/user-auth";
+import uploadAndRecordMedia from "@/src/functions/backend/db/users/media/upload-and-record-media";
+import type { ApiReqParams } from "@/src/types";
+import bufferFromBase64 from "@/src/utils/buffer-from-base-64";
+import type {
+    APIResponseObject,
+    BunextAPIRouteHandler,
+} from "@moduletrace/bunext/types";
+import _ from "lodash";
+
+export const handler: BunextAPIRouteHandler<APIResponseObject> = async (
+    params,
+) => {
+    const req = params.req;
+    const body = params.body as ApiReqParams;
+
+    if (req.method !== "POST") {
+        return {
+            success: false,
+        };
+    }
+
+    const { user, user_types } = await userAuth({ req });
+
+    if (!user?.logged_in_status) {
+        return {
+            success: false,
+            msg: `Unauthorized`,
+            logoutUser: true,
+        };
+    }
+
+    try {
+        const {
+            user_id,
+            media_base_64_data_url,
+            media_paradigms,
+            media_type,
+            is_media_primary,
+            update_on_duplicate,
+            reauth,
+            return_media_text_content,
+            media,
+            is_media_private,
+            media_name,
+        } = body;
+
+        if (!media_base_64_data_url) {
+            throw new Error(
+                `No image payload sent! Base64 data URL with mime type is required.`,
+            );
+        }
+
+        const { buffer, ext } = await bufferFromBase64(media_base_64_data_url);
+
+        const new_media = await uploadAndRecordMedia({
+            data: buffer,
+            media_paradigms,
+            media_type,
+            is_primary: is_media_primary,
+            update_on_duplicate,
+            extract_media_text_content: return_media_text_content,
+            media,
+            media_mime_type: ext,
+            user: { id: twuiNumberfy(user_id) },
+            is_private: is_media_private,
+            media_name,
+        });
+
+        if (reauth) {
+            return await loginUser({
+                user_id: Number(user_id),
+            });
+        }
+
+        return {
+            ...new_media,
+        };
+    } catch (error: any) {
+        return {
+            success: false,
+            msg: error.message,
+        };
+    }
+};