infoalloggi-monorepo/apps/infoalloggi/src/server/services/storage.service.ts

import { TRPCError } from "@trpc/server";
import { env } from "~/env";
import type {
	StorageindexId,
	StorageindexUpdate,
} from "~/schemas/public/Storageindex";
import type { TempTokensToken } from "~/schemas/public/TempTokens";
import type { UsersId } from "~/schemas/public/Users";
import type { Querier } from "~/server/db";
import { deleteFile } from "../storage";

export const getNewTokenHandler = async ({
	db,
	num,
}: {
	db: Querier;
	num?: number;
}): Promise<TempTokensToken[]> => {
	const tokens: TempTokensToken[] = [];
	if (num && num > 1) {
		for (let i = 0; i < num; i++) {
			const tok = await newToken({ db });

			tokens.push(tok.token);
		}
		return tokens;
	}
	const tok = await newToken({ db });
	return [tok.token];
};

const newToken = async ({ db }: { db: Querier }) => {
	try {
		return await db
			.insertInto("temp_tokens")
			.defaultValues()
			.returning("token")
			.executeTakeFirstOrThrow();
	} catch {
		throw new TRPCError({
			code: "INTERNAL_SERVER_ERROR",
			message: "Error while creating token",
		});
	}
};

export const deleteHandler = async ({
	db,
	fileId,
	cb,
}: {
	db: Querier;
	fileId: StorageindexId;
	cb?: (fileId: StorageindexId) => Promise<void>;
}) => {
	try {
		const storage = await db
			.selectFrom("storageindex")
			.select(["id", "ext"])
			.where("id", "=", fileId)
			.executeTakeFirstOrThrow();
		await deleteFile(storage.id);

		if (cb) {
			await cb(fileId);
		}
	} catch (error) {
		console.error("Error:", error);
		throw new TRPCError({
			code: "INTERNAL_SERVER_ERROR",
			message: "Error while deleting file",
		});
	}
};

export const updateHandler = async ({
	db,
	fileId,
	data,
}: {
	db: Querier;
	fileId: StorageindexId;
	data: StorageindexUpdate;
}) => {
	try {
		await db
			.updateTable("storageindex")
			.set(data)
			.where("id", "=", fileId)
			.execute();
		return "ok";
	} catch (e) {
		throw new TRPCError({
			code: "INTERNAL_SERVER_ERROR",
			message: `Error while updating file: ${(e as Error).message}`,
		});
	}
};

export const addUserStorageJunc = async ({
	db,
	userId,
	storageId,
}: {
	db: Querier;
	userId: UsersId;
	storageId: StorageindexId;
}) => {
	try {
		return await db
			.insertInto("users_storage")
			.values({ storageid: storageId, userid: userId })
			.onConflict((oc) => oc.columns(["userid", "storageid"]).doNothing())
			.returningAll()
			.execute();
	} catch (e) {
		throw new TRPCError({
			code: "INTERNAL_SERVER_ERROR",
			message: `Error while adding user storage: ${(e as Error).message}`,
		});
	}
};

export const deleteUserStorageJunc = async ({
	db,
	userId,
	storageId,
}: {
	db: Querier;
	userId: UsersId;
	storageId: StorageindexId;
}) => {
	try {
		await db
			.deleteFrom("users_storage")
			.where("userid", "=", userId)
			.where("storageid", "=", storageId)
			.execute();
		return "ok";
	} catch (e) {
		throw new TRPCError({
			code: "INTERNAL_SERVER_ERROR",
			message: `Error while deleting user storage: ${(e as Error).message}`,
		});
	}
};