kmc7468/arkvault
1
0
Fork 0
mirror of https://github.com/kmc7468/arkvault.git synced 2026-02-04 08:06:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

FileRepo의 함수 중 디렉터리 관련된 함수들을 DirectoryRepo로 분리

Browse Source
This commit is contained in:
static
2026-01-18 12:34:04 +09:00
parent 14693160b8
commit 4797ccfd23
19 changed files with 417 additions and 562 deletions
Download Patch File Download Diff File Expand all files Collapse all files

245
src/lib/server/db/directory.ts Normal file
View File

@@ -0,0 +1,245 @@
import type { Selectable } from "kysely";
import { IntegrityError } from "./error";
import db from "./kysely";
import type { Ciphertext, DirectoryTable } from "./schema";
interface Directory {
id: number;
parentId: DirectoryId;
userId: number;
mekVersion: number;
encDek: string;
dekVersion: Date;
encName: Ciphertext;
isFavorite: boolean;
}
const toDirectory = (row: Selectable<DirectoryTable>): Directory => ({
id: row.id,
parentId: row.parent_id ?? "root",
userId: row.user_id,
mekVersion: row.master_encryption_key_version,
encDek: row.encrypted_data_encryption_key,
dekVersion: row.data_encryption_key_version,
encName: row.encrypted_name,
isFavorite: row.is_favorite,
});
export const registerDirectory = async (params: Omit<Directory, "id" | "isFavorite">) => {
await db.transaction().execute(async (trx) => {
const mek = await trx
.selectFrom("master_encryption_key")
.select("version")
.where("user_id", "=", params.userId)
.where("state", "=", "active")
.limit(1)
.forUpdate()
.executeTakeFirst();
if (mek?.version !== params.mekVersion) {
throw new IntegrityError("Inactive MEK version");
}
const { directoryId } = await trx
.insertInto("directory")
.values({
parent_id: params.parentId !== "root" ? params.parentId : null,
user_id: params.userId,
master_encryption_key_version: params.mekVersion,
encrypted_data_encryption_key: params.encDek,
data_encryption_key_version: params.dekVersion,
encrypted_name: params.encName,
})
.returning("id as directoryId")
.executeTakeFirstOrThrow();
await trx
.insertInto("directory_log")
.values({
directory_id: directoryId,
timestamp: new Date(),
action: "create",
new_name: params.encName,
})
.execute();
});
};
export const getAllDirectoriesByParent = async (userId: number, parentId: DirectoryId) => {
const directories = await db
.selectFrom("directory")
.selectAll()
.where("user_id", "=", userId)
.$if(parentId === "root", (qb) => qb.where("parent_id", "is", null))
.$if(parentId !== "root", (qb) => qb.where("parent_id", "=", parentId as number))
.execute();
return directories.map(toDirectory);
};
export const getAllRecursiveDirectoriesByParent = async (userId: number, parentId: DirectoryId) => {
const directories = await db
.withRecursive("directory_tree", (db) =>
db
.selectFrom("directory")
.selectAll()
.$if(parentId === "root", (qb) => qb.where("parent_id", "is", null))
.$if(parentId !== "root", (qb) => qb.where("parent_id", "=", parentId as number))
.where("user_id", "=", userId)
.unionAll((db) =>
db
.selectFrom("directory")
.innerJoin("directory_tree", "directory.parent_id", "directory_tree.id")
.selectAll("directory"),
),
)
.selectFrom("directory_tree")
.selectAll()
.execute();
return directories.map(toDirectory);
};
export const getAllFavoriteDirectories = async (userId: number) => {
const directories = await db
.selectFrom("directory")
.selectAll()
.where("user_id", "=", userId)
.where("is_favorite", "=", true)
.execute();
return directories.map(toDirectory);
};
export const getDirectory = async (userId: number, directoryId: number) => {
const directory = await db
.selectFrom("directory")
.selectAll()
.where("id", "=", directoryId)
.where("user_id", "=", userId)
.limit(1)
.executeTakeFirst();
return directory ? toDirectory(directory) : null;
};
export const setDirectoryEncName = async (
userId: number,
directoryId: number,
dekVersion: Date,
encName: Ciphertext,
) => {
await db.transaction().execute(async (trx) => {
const directory = await trx
.selectFrom("directory")
.select("data_encryption_key_version")
.where("id", "=", directoryId)
.where("user_id", "=", userId)
.limit(1)
.forUpdate()
.executeTakeFirst();
if (!directory) {
throw new IntegrityError("Directory not found");
} else if (directory.data_encryption_key_version.getTime() !== dekVersion.getTime()) {
throw new IntegrityError("Invalid DEK version");
}
await trx
.updateTable("directory")
.set({ encrypted_name: encName })
.where("id", "=", directoryId)
.where("user_id", "=", userId)
.execute();
await trx
.insertInto("directory_log")
.values({
directory_id: directoryId,
timestamp: new Date(),
action: "rename",
new_name: encName,
})
.execute();
});
};
export const setDirectoryFavorite = async (
userId: number,
directoryId: number,
isFavorite: boolean,
) => {
await db.transaction().execute(async (trx) => {
const directory = await trx
.selectFrom("directory")
.select("is_favorite")
.where("id", "=", directoryId)
.where("user_id", "=", userId)
.limit(1)
.forUpdate()
.executeTakeFirst();
if (!directory) {
throw new IntegrityError("Directory not found");
} else if (directory.is_favorite === isFavorite) {
throw new IntegrityError(
isFavorite ? "Directory already favorited" : "Directory not favorited",
);
}
await trx
.updateTable("directory")
.set({ is_favorite: isFavorite })
.where("id", "=", directoryId)
.where("user_id", "=", userId)
.execute();
await trx
.insertInto("directory_log")
.values({
directory_id: directoryId,
timestamp: new Date(),
action: isFavorite ? "add-to-favorites" : "remove-from-favorites",
})
.execute();
});
};
export const unregisterDirectory = async (userId: number, directoryId: number) => {
return await db
.transaction()
.setIsolationLevel("repeatable read") // TODO: Sufficient?
.execute(async (trx) => {
const unregisterFiles = async (parentId: number) => {
const files = await trx
.selectFrom("file")
.leftJoin("thumbnail", "file.id", "thumbnail.file_id")
.select(["file.id", "file.path", "thumbnail.path as thumbnailPath"])
.where("file.parent_id", "=", parentId)
.where("file.user_id", "=", userId)
.forUpdate("file")
.execute();
await trx
.deleteFrom("file")
.where("parent_id", "=", parentId)
.where("user_id", "=", userId)
.execute();
return files;
};
const unregisterDirectoryRecursively = async (
directoryId: number,
): Promise<{ id: number; path: string; thumbnailPath: string | null }[]> => {
const files = await unregisterFiles(directoryId);
const subDirectories = await trx
.selectFrom("directory")
.select("id")
.where("parent_id", "=", directoryId)
.where("user_id", "=", userId)
.execute();
const subDirectoryFilePaths = await Promise.all(
subDirectories.map(async ({ id }) => await unregisterDirectoryRecursively(id)),
);
const deleteRes = await trx
.deleteFrom("directory")
.where("id", "=", directoryId)
.where("user_id", "=", userId)
.executeTakeFirst();
if (deleteRes.numDeletedRows === 0n) {
throw new IntegrityError("Directory not found");
}
return files.concat(...subDirectoryFilePaths);
};
return await unregisterDirectoryRecursively(directoryId);
});
};

513
src/lib/server/db/file.ts
View File

@@ -1,20 +1,9 @@
import { sql } from "kysely"; import { sql, type Selectable } from "kysely";
import { jsonArrayFrom } from "kysely/helpers/postgres"; import { jsonArrayFrom } from "kysely/helpers/postgres";
import pg from "pg"; import pg from "pg";
import { IntegrityError } from "./error"; import { IntegrityError } from "./error";
import db from "./kysely"; import db from "./kysely";
import type { Ciphertext } from "./schema"; import type { Ciphertext, FileTable } from "./schema";
interface Directory {
id: number;
parentId: DirectoryId;
userId: number;
mekVersion: number;
encDek: string;
dekVersion: Date;
encName: Ciphertext;
isFavorite: boolean;
}
interface File { interface File {
id: number; id: number;
@@ -44,209 +33,24 @@ interface FileCategory {
encName: Ciphertext; encName: Ciphertext;
} }
export const registerDirectory = async (params: Omit<Directory, "id" | "isFavorite">) => { const toFile = (row: Selectable<FileTable>): File => ({
await db.transaction().execute(async (trx) => { id: row.id,
const mek = await trx parentId: row.parent_id ?? "root",
.selectFrom("master_encryption_key") userId: row.user_id,
.select("version") path: row.path,
.where("user_id", "=", params.userId) mekVersion: row.master_encryption_key_version,
.where("state", "=", "active") encDek: row.encrypted_data_encryption_key,
.limit(1) dekVersion: row.data_encryption_key_version,
.forUpdate() hskVersion: row.hmac_secret_key_version,
.executeTakeFirst(); contentHmac: row.content_hmac,
if (mek?.version !== params.mekVersion) { contentType: row.content_type,
throw new IntegrityError("Inactive MEK version"); encContentIv: row.encrypted_content_iv,
} encContentHash: row.encrypted_content_hash,
encName: row.encrypted_name,
const { directoryId } = await trx encCreatedAt: row.encrypted_created_at,
.insertInto("directory") encLastModifiedAt: row.encrypted_last_modified_at,
.values({ isFavorite: row.is_favorite,
parent_id: params.parentId !== "root" ? params.parentId : null, });
user_id: params.userId,
master_encryption_key_version: params.mekVersion,
encrypted_data_encryption_key: params.encDek,
data_encryption_key_version: params.dekVersion,
encrypted_name: params.encName,
})
.returning("id as directoryId")
.executeTakeFirstOrThrow();
await trx
.insertInto("directory_log")
.values({
directory_id: directoryId,
timestamp: new Date(),
action: "create",
new_name: params.encName,
})
.execute();
});
};
export const getAllDirectoriesByParent = async (userId: number, parentId: DirectoryId) => {
let query = db.selectFrom("directory").selectAll().where("user_id", "=", userId);
query =
parentId === "root"
? query.where("parent_id", "is", null)
: query.where("parent_id", "=", parentId);
const directories = await query.execute();
return directories.map(
(directory) =>
({
id: directory.id,
parentId: directory.parent_id ?? "root",
userId: directory.user_id,
mekVersion: directory.master_encryption_key_version,
encDek: directory.encrypted_data_encryption_key,
dekVersion: directory.data_encryption_key_version,
encName: directory.encrypted_name,
isFavorite: directory.is_favorite,
}) satisfies Directory,
);
};
export const getAllRecursiveDirectoriesByParent = async (userId: number, parentId: DirectoryId) => {
const directories = await db
.withRecursive("directory_tree", (db) =>
db
.selectFrom("directory")
.selectAll()
.$if(parentId === "root", (qb) => qb.where("parent_id", "is", null))
.$if(parentId !== "root", (qb) => qb.where("parent_id", "=", parentId as number))
.where("user_id", "=", userId)
.unionAll((db) =>
db
.selectFrom("directory")
.innerJoin("directory_tree", "directory.parent_id", "directory_tree.id")
.selectAll("directory"),
),
)
.selectFrom("directory_tree")
.selectAll()
.execute();
return directories.map(
(directory) =>
({
id: directory.id,
parentId: directory.parent_id ?? "root",
userId: directory.user_id,
mekVersion: directory.master_encryption_key_version,
encDek: directory.encrypted_data_encryption_key,
dekVersion: directory.data_encryption_key_version,
encName: directory.encrypted_name,
isFavorite: directory.is_favorite,
}) satisfies Directory,
);
};
export const getDirectory = async (userId: number, directoryId: number) => {
const directory = await db
.selectFrom("directory")
.selectAll()
.where("id", "=", directoryId)
.where("user_id", "=", userId)
.limit(1)
.executeTakeFirst();
return directory
? ({
id: directory.id,
parentId: directory.parent_id ?? "root",
userId: directory.user_id,
mekVersion: directory.master_encryption_key_version,
encDek: directory.encrypted_data_encryption_key,
dekVersion: directory.data_encryption_key_version,
encName: directory.encrypted_name,
isFavorite: directory.is_favorite,
} satisfies Directory)
: null;
};
export const setDirectoryEncName = async (
userId: number,
directoryId: number,
dekVersion: Date,
encName: Ciphertext,
) => {
await db.transaction().execute(async (trx) => {
const directory = await trx
.selectFrom("directory")
.select("data_encryption_key_version")
.where("id", "=", directoryId)
.where("user_id", "=", userId)
.limit(1)
.forUpdate()
.executeTakeFirst();
if (!directory) {
throw new IntegrityError("Directory not found");
} else if (directory.data_encryption_key_version.getTime() !== dekVersion.getTime()) {
throw new IntegrityError("Invalid DEK version");
}
await trx
.updateTable("directory")
.set({ encrypted_name: encName })
.where("id", "=", directoryId)
.where("user_id", "=", userId)
.execute();
await trx
.insertInto("directory_log")
.values({
directory_id: directoryId,
timestamp: new Date(),
action: "rename",
new_name: encName,
})
.execute();
});
};
export const unregisterDirectory = async (userId: number, directoryId: number) => {
return await db
.transaction()
.setIsolationLevel("repeatable read") // TODO: Sufficient?
.execute(async (trx) => {
const unregisterFiles = async (parentId: number) => {
const files = await trx
.selectFrom("file")
.leftJoin("thumbnail", "file.id", "thumbnail.file_id")
.select(["file.id", "file.path", "thumbnail.path as thumbnailPath"])
.where("file.parent_id", "=", parentId)
.where("file.user_id", "=", userId)
.forUpdate("file")
.execute();
await trx
.deleteFrom("file")
.where("parent_id", "=", parentId)
.where("user_id", "=", userId)
.execute();
return files;
};
const unregisterDirectoryRecursively = async (
directoryId: number,
): Promise<{ id: number; path: string; thumbnailPath: string | null }[]> => {
const files = await unregisterFiles(directoryId);
const subDirectories = await trx
.selectFrom("directory")
.select("id")
.where("parent_id", "=", directoryId)
.where("user_id", "=", userId)
.execute();
const subDirectoryFilePaths = await Promise.all(
subDirectories.map(async ({ id }) => await unregisterDirectoryRecursively(id)),
);
const deleteRes = await trx
.deleteFrom("directory")
.where("id", "=", directoryId)
.where("user_id", "=", userId)
.executeTakeFirst();
if (deleteRes.numDeletedRows === 0n) {
throw new IntegrityError("Directory not found");
}
return files.concat(...subDirectoryFilePaths);
};
return await unregisterDirectoryRecursively(directoryId);
});
};
export const registerFile = async (trx: typeof db, params: Omit<File, "id" | "isFavorite">) => { export const registerFile = async (trx: typeof db, params: Omit<File, "id" | "isFavorite">) => {
if ((params.hskVersion && !params.contentHmac) || (!params.hskVersion && params.contentHmac)) { if ((params.hskVersion && !params.contentHmac) || (!params.hskVersion && params.contentHmac)) {
@@ -286,33 +90,14 @@ export const registerFile = async (trx: typeof db, params: Omit<File, "id" | "is
}; };
export const getAllFilesByParent = async (userId: number, parentId: DirectoryId) => { export const getAllFilesByParent = async (userId: number, parentId: DirectoryId) => {
let query = db.selectFrom("file").selectAll().where("user_id", "=", userId); const files = await db
query = .selectFrom("file")
parentId === "root" .selectAll()
? query.where("parent_id", "is", null) .where("user_id", "=", userId)
: query.where("parent_id", "=", parentId); .$if(parentId === "root", (qb) => qb.where("parent_id", "is", null))
const files = await query.execute(); .$if(parentId !== "root", (qb) => qb.where("parent_id", "=", parentId as number))
return files.map( .execute();
(file) => return files.map(toFile);
({
id: file.id,
parentId: file.parent_id ?? "root",
userId: file.user_id,
path: file.path,
mekVersion: file.master_encryption_key_version,
encDek: file.encrypted_data_encryption_key,
dekVersion: file.data_encryption_key_version,
hskVersion: file.hmac_secret_key_version,
contentHmac: file.content_hmac,
contentType: file.content_type,
encContentIv: file.encrypted_content_iv,
encContentHash: file.encrypted_content_hash,
encName: file.encrypted_name,
encCreatedAt: file.encrypted_created_at,
encLastModifiedAt: file.encrypted_last_modified_at,
isFavorite: file.is_favorite,
}) satisfies File,
);
}; };
export const getAllFilesByCategory = async ( export const getAllFilesByCategory = async (
@@ -345,28 +130,10 @@ export const getAllFilesByCategory = async (
.orderBy("file_id") .orderBy("file_id")
.orderBy("depth") .orderBy("depth")
.execute(); .execute();
return files.map( return files.map((file) => ({
(file) => ...toFile(file),
({ isRecursive: file.depth > 0,
id: file.file_id, }));
parentId: file.parent_id ?? "root",
userId: file.user_id,
path: file.path,
mekVersion: file.master_encryption_key_version,
encDek: file.encrypted_data_encryption_key,
dekVersion: file.data_encryption_key_version,
hskVersion: file.hmac_secret_key_version,
contentHmac: file.content_hmac,
contentType: file.content_type,
encContentIv: file.encrypted_content_iv,
encContentHash: file.encrypted_content_hash,
encName: file.encrypted_name,
encCreatedAt: file.encrypted_created_at,
encLastModifiedAt: file.encrypted_last_modified_at,
isFavorite: file.is_favorite,
isRecursive: file.depth > 0,
}) satisfies File & { isRecursive: boolean },
);
}; };
export const getAllFileIds = async (userId: number) => { export const getAllFileIds = async (userId: number) => {
@@ -382,27 +149,7 @@ export const getLegacyFiles = async (userId: number, limit: number = 100) => {
.where("encrypted_content_iv", "is not", null) .where("encrypted_content_iv", "is not", null)
.limit(limit) .limit(limit)
.execute(); .execute();
return files.map( return files.map(toFile);
(file) =>
({
id: file.id,
parentId: file.parent_id ?? "root",
userId: file.user_id,
path: file.path,
mekVersion: file.master_encryption_key_version,
encDek: file.encrypted_data_encryption_key,
dekVersion: file.data_encryption_key_version,
hskVersion: file.hmac_secret_key_version,
contentHmac: file.content_hmac,
contentType: file.content_type,
encContentIv: file.encrypted_content_iv,
encContentHash: file.encrypted_content_hash,
encName: file.encrypted_name,
encCreatedAt: file.encrypted_created_at,
encLastModifiedAt: file.encrypted_last_modified_at,
isFavorite: file.is_favorite,
}) satisfies File,
);
}; };
export const getFilesWithoutThumbnail = async (userId: number, limit: number = 100) => { export const getFilesWithoutThumbnail = async (userId: number, limit: number = 100) => {
@@ -426,27 +173,7 @@ export const getFilesWithoutThumbnail = async (userId: number, limit: number = 1
) )
.limit(limit) .limit(limit)
.execute(); .execute();
return files.map( return files.map(toFile);
(file) =>
({
id: file.id,
parentId: file.parent_id ?? "root",
userId: file.user_id,
path: file.path,
mekVersion: file.master_encryption_key_version,
encDek: file.encrypted_data_encryption_key,
dekVersion: file.data_encryption_key_version,
hskVersion: file.hmac_secret_key_version,
contentHmac: file.content_hmac,
contentType: file.content_type,
encContentIv: file.encrypted_content_iv,
encContentHash: file.encrypted_content_hash,
encName: file.encrypted_name,
encCreatedAt: file.encrypted_created_at,
encLastModifiedAt: file.encrypted_last_modified_at,
isFavorite: file.is_favorite,
}) satisfies File,
);
}; };
export const getAllFileIdsByContentHmac = async ( export const getAllFileIdsByContentHmac = async (
@@ -472,26 +199,7 @@ export const getFile = async (userId: number, fileId: number) => {
.where("user_id", "=", userId) .where("user_id", "=", userId)
.limit(1) .limit(1)
.executeTakeFirst(); .executeTakeFirst();
return file return file ? toFile(file) : null;
? ({
id: file.id,
parentId: file.parent_id ?? "root",
userId: file.user_id,
path: file.path,
mekVersion: file.master_encryption_key_version,
encDek: file.encrypted_data_encryption_key,
dekVersion: file.data_encryption_key_version,
hskVersion: file.hmac_secret_key_version,
contentHmac: file.content_hmac,
contentType: file.content_type,
encContentIv: file.encrypted_content_iv,
encContentHash: file.encrypted_content_hash,
encName: file.encrypted_name,
encCreatedAt: file.encrypted_created_at,
encLastModifiedAt: file.encrypted_last_modified_at,
isFavorite: file.is_favorite,
} satisfies File)
: null;
}; };
export const getFilesWithCategories = async (userId: number, fileIds: number[]) => { export const getFilesWithCategories = async (userId: number, fileIds: number[]) => {
@@ -510,35 +218,30 @@ export const getFilesWithCategories = async (userId: number, fileIds: number[])
.where("id", "=", (eb) => eb.fn.any(eb.val(fileIds))) .where("id", "=", (eb) => eb.fn.any(eb.val(fileIds)))
.where("user_id", "=", userId) .where("user_id", "=", userId)
.execute(); .execute();
return files.map( return files.map((file) => ({
(file) => ...toFile(file),
({ categories: file.categories.map(
id: file.id, (category) =>
parentId: file.parent_id ?? "root", ({
userId: file.user_id,
path: file.path,
mekVersion: file.master_encryption_key_version,
encDek: file.encrypted_data_encryption_key,
dekVersion: file.data_encryption_key_version,
hskVersion: file.hmac_secret_key_version,
contentHmac: file.content_hmac,
contentType: file.content_type,
encContentIv: file.encrypted_content_iv,
encContentHash: file.encrypted_content_hash,
encName: file.encrypted_name,
encCreatedAt: file.encrypted_created_at,
encLastModifiedAt: file.encrypted_last_modified_at,
isFavorite: file.is_favorite,
categories: file.categories.map((category) => ({
id: category.id, id: category.id,
parentId: category.parent_id ?? "root", parentId: category.parent_id ?? "root",
mekVersion: category.master_encryption_key_version, mekVersion: category.master_encryption_key_version,
encDek: category.encrypted_data_encryption_key, encDek: category.encrypted_data_encryption_key,
dekVersion: new Date(category.data_encryption_key_version), dekVersion: new Date(category.data_encryption_key_version),
encName: category.encrypted_name, encName: category.encrypted_name,
})), }) satisfies FileCategory,
}) satisfies File & { categories: FileCategory[] }, ),
); }));
};
export const getAllFavoriteFiles = async (userId: number) => {
const files = await db
.selectFrom("file")
.selectAll()
.where("user_id", "=", userId)
.where("is_favorite", "=", true)
.execute();
return files.map(toFile);
}; };
export const searchFiles = async ( export const searchFiles = async (
@@ -625,24 +328,7 @@ export const searchFiles = async (
) )
.execute() .execute()
: await baseQuery.execute(); : await baseQuery.execute();
return files.map((file) => ({ return files.map(toFile);
id: file.id,
parentId: file.parent_id ?? ("root" as const),
userId: file.user_id,
path: file.path,
mekVersion: file.master_encryption_key_version,
encDek: file.encrypted_data_encryption_key,
dekVersion: file.data_encryption_key_version,
hskVersion: file.hmac_secret_key_version,
contentHmac: file.content_hmac,
contentType: file.content_type,
encContentIv: file.encrypted_content_iv,
encContentHash: file.encrypted_content_hash,
encName: file.encrypted_name,
encCreatedAt: file.encrypted_created_at,
encLastModifiedAt: file.encrypted_last_modified_at,
isFavorite: file.is_favorite,
}));
}; };
export const setFileEncName = async ( export const setFileEncName = async (
@@ -848,94 +534,3 @@ export const setFileFavorite = async (userId: number, fileId: number, isFavorite
.execute(); .execute();
}); });
}; };
export const setDirectoryFavorite = async (
userId: number,
directoryId: number,
isFavorite: boolean,
) => {
await db.transaction().execute(async (trx) => {
const directory = await trx
.selectFrom("directory")
.select("is_favorite")
.where("id", "=", directoryId)
.where("user_id", "=", userId)
.limit(1)
.forUpdate()
.executeTakeFirst();
if (!directory) {
throw new IntegrityError("Directory not found");
} else if (directory.is_favorite === isFavorite) {
throw new IntegrityError(
isFavorite ? "Directory already favorited" : "Directory not favorited",
);
}
await trx
.updateTable("directory")
.set({ is_favorite: isFavorite })
.where("id", "=", directoryId)
.where("user_id", "=", userId)
.execute();
await trx
.insertInto("directory_log")
.values({
directory_id: directoryId,
timestamp: new Date(),
action: isFavorite ? "add-to-favorites" : "remove-from-favorites",
})
.execute();
});
};
export const getAllFavoriteFiles = async (userId: number) => {
const files = await db
.selectFrom("file")
.selectAll()
.where("user_id", "=", userId)
.where("is_favorite", "=", true)
.execute();
return files.map(
(file) =>
({
id: file.id,
parentId: file.parent_id ?? "root",
userId: file.user_id,
path: file.path,
mekVersion: file.master_encryption_key_version,
encDek: file.encrypted_data_encryption_key,
dekVersion: file.data_encryption_key_version,
hskVersion: file.hmac_secret_key_version,
contentHmac: file.content_hmac,
contentType: file.content_type,
encContentIv: file.encrypted_content_iv,
encContentHash: file.encrypted_content_hash,
encName: file.encrypted_name,
encCreatedAt: file.encrypted_created_at,
encLastModifiedAt: file.encrypted_last_modified_at,
isFavorite: file.is_favorite,
}) satisfies File,
);
};
export const getAllFavoriteDirectories = async (userId: number) => {
const directories = await db
.selectFrom("directory")
.selectAll()
.where("user_id", "=", userId)
.where("is_favorite", "=", true)
.execute();
return directories.map(
(directory) =>
({
id: directory.id,
parentId: directory.parent_id ?? "root",
userId: directory.user_id,
mekVersion: directory.master_encryption_key_version,
encDek: directory.encrypted_data_encryption_key,
dekVersion: directory.data_encryption_key_version,
encName: directory.encrypted_name,
isFavorite: directory.is_favorite,
}) satisfies Directory,
);
};

1
src/lib/server/db/index.ts
View File

@@ -1,5 +1,6 @@
export * as CategoryRepo from "./category"; export * as CategoryRepo from "./category";
export * as ClientRepo from "./client"; export * as ClientRepo from "./client";
export * as DirectoryRepo from "./directory";
export * as FileRepo from "./file"; export * as FileRepo from "./file";
export * as HskRepo from "./hsk"; export * as HskRepo from "./hsk";
export * as MediaRepo from "./media"; export * as MediaRepo from "./media";

4
src/lib/server/db/migrations/1737357000-Initial.ts
View File

@@ -135,7 +135,7 @@ export const up = async (db: Kysely<any>) => {
) )
.execute(); .execute();
// file.ts // directory.ts
await db.schema await db.schema
.createTable("directory") .createTable("directory")
.addColumn("id", "integer", (col) => col.primaryKey().generatedAlwaysAsIdentity()) .addColumn("id", "integer", (col) => col.primaryKey().generatedAlwaysAsIdentity())
@@ -162,6 +162,8 @@ export const up = async (db: Kysely<any>) => {
.addColumn("action", "text", (col) => col.notNull()) .addColumn("action", "text", (col) => col.notNull())
.addColumn("new_name", "json") .addColumn("new_name", "json")
.execute(); .execute();
// file.ts
await db.schema await db.schema
.createTable("file") .createTable("file")
.addColumn("id", "integer", (col) => col.primaryKey().generatedAlwaysAsIdentity()) .addColumn("id", "integer", (col) => col.primaryKey().generatedAlwaysAsIdentity())

4
src/lib/server/db/migrations/1768643000-AddFavorites.ts
View File

@@ -2,11 +2,13 @@ import { Kysely } from "kysely";
// eslint-disable-next-line @typescript-eslint/no-explicit-any // eslint-disable-next-line @typescript-eslint/no-explicit-any
export const up = async (db: Kysely<any>) => { export const up = async (db: Kysely<any>) => {
// file.ts // directory.ts
await db.schema await db.schema
.alterTable("directory") .alterTable("directory")
.addColumn("is_favorite", "boolean", (col) => col.notNull().defaultTo(false)) .addColumn("is_favorite", "boolean", (col) => col.notNull().defaultTo(false))
.execute(); .execute();
// file.ts
await db.schema await db.schema
.alterTable("file") .alterTable("file")
.addColumn("is_favorite", "boolean", (col) => col.notNull().defaultTo(false)) .addColumn("is_favorite", "boolean", (col) => col.notNull().defaultTo(false))

4
src/lib/server/db/schema/category.ts
View File

@@ -1,7 +1,7 @@
import type { Generated } from "kysely"; import type { Generated } from "kysely";
import type { Ciphertext } from "./utils"; import type { Ciphertext } from "./utils";
interface CategoryTable { export interface CategoryTable {
id: Generated<number>; id: Generated<number>;
parent_id: number | null; parent_id: number | null;
user_id: number; user_id: number;
@@ -11,7 +11,7 @@ interface CategoryTable {
encrypted_name: Ciphertext; encrypted_name: Ciphertext;
} }
interface CategoryLogTable { export interface CategoryLogTable {
id: Generated<number>; id: Generated<number>;
category_id: number; category_id: number;
timestamp: Date; timestamp: Date;

6
src/lib/server/db/schema/client.ts
View File

@@ -1,6 +1,6 @@
import type { ColumnType, Generated } from "kysely"; import type { ColumnType, Generated } from "kysely";
interface ClientTable { export interface ClientTable {
id: Generated<number>; id: Generated<number>;
encryption_public_key: string; // Base64 encryption_public_key: string; // Base64
signature_public_key: string; // Base64 signature_public_key: string; // Base64
@@ -8,13 +8,13 @@ interface ClientTable {
export type UserClientState = "challenging" | "pending" | "active"; export type UserClientState = "challenging" | "pending" | "active";
interface UserClientTable { export interface UserClientTable {
user_id: number; user_id: number;
client_id: number; client_id: number;
state: ColumnType<UserClientState, UserClientState | undefined>; state: ColumnType<UserClientState, UserClientState | undefined>;
} }
interface UserClientChallengeTable { export interface UserClientChallengeTable {
id: Generated<number>; id: Generated<number>;
user_id: number; user_id: number;
client_id: number; client_id: number;

28
src/lib/server/db/schema/directory.ts Normal file
View File

@@ -0,0 +1,28 @@
import type { ColumnType, Generated } from "kysely";
import type { Ciphertext } from "./utils";
export interface DirectoryTable {
id: Generated<number>;
parent_id: number | null;
user_id: number;
master_encryption_key_version: number;
encrypted_data_encryption_key: string; // Base64
data_encryption_key_version: Date;
encrypted_name: Ciphertext;
is_favorite: Generated<boolean>;
}
export interface DirectoryLogTable {
id: Generated<number>;
directory_id: number;
timestamp: ColumnType<Date, Date, never>;
action: "create" | "rename" | "add-to-favorites" | "remove-from-favorites";
new_name: Ciphertext | null;
}
declare module "./index" {
interface Database {
directory: DirectoryTable;
directory_log: DirectoryLogTable;
}
}

27
src/lib/server/db/schema/file.ts
View File

@@ -1,26 +1,7 @@
import type { ColumnType, Generated } from "kysely"; import type { ColumnType, Generated } from "kysely";
import type { Ciphertext } from "./utils"; import type { Ciphertext } from "./utils";
interface DirectoryTable { export interface FileTable {
id: Generated<number>;
parent_id: number | null;
user_id: number;
master_encryption_key_version: number;
encrypted_data_encryption_key: string; // Base64
data_encryption_key_version: Date;
encrypted_name: Ciphertext;
is_favorite: Generated<boolean>;
}
interface DirectoryLogTable {
id: Generated<number>;
directory_id: number;
timestamp: ColumnType<Date, Date, never>;
action: "create" | "rename" | "add-to-favorites" | "remove-from-favorites";
new_name: Ciphertext | null;
}
interface FileTable {
id: Generated<number>; id: Generated<number>;
parent_id: number | null; parent_id: number | null;
user_id: number; user_id: number;
@@ -39,7 +20,7 @@ interface FileTable {
is_favorite: Generated<boolean>; is_favorite: Generated<boolean>;
} }
interface FileLogTable { export interface FileLogTable {
id: Generated<number>; id: Generated<number>;
file_id: number; file_id: number;
timestamp: ColumnType<Date, Date, never>; timestamp: ColumnType<Date, Date, never>;
@@ -55,15 +36,13 @@ interface FileLogTable {
category_id: number | null; category_id: number | null;
} }
interface FileCategoryTable { export interface FileCategoryTable {
file_id: number; file_id: number;
category_id: number; category_id: number;
} }
declare module "./index" { declare module "./index" {
interface Database { interface Database {
directory: DirectoryTable;
directory_log: DirectoryLogTable;
file: FileTable; file: FileTable;
file_log: FileLogTable; file_log: FileLogTable;
file_category: FileCategoryTable; file_category: FileCategoryTable;

4
src/lib/server/db/schema/hsk.ts
View File

@@ -2,7 +2,7 @@ import type { ColumnType, Generated } from "kysely";
export type HskState = "active"; export type HskState = "active";
interface HskTable { export interface HskTable {
user_id: number; user_id: number;
version: number; version: number;
state: HskState; state: HskState;
@@ -10,7 +10,7 @@ interface HskTable {
encrypted_key: string; // Base64 encrypted_key: string; // Base64
} }
interface HskLogTable { export interface HskLogTable {
id: Generated<number>; id: Generated<number>;
user_id: number; user_id: number;
hmac_secret_key_version: number; hmac_secret_key_version: number;

1
src/lib/server/db/schema/index.ts
View File

@@ -1,5 +1,6 @@
export * from "./category"; export * from "./category";
export * from "./client"; export * from "./client";
export * from "./directory";
export * from "./file"; export * from "./file";
export * from "./hsk"; export * from "./hsk";
export * from "./media"; export * from "./media";

2
src/lib/server/db/schema/media.ts
View File

@@ -1,6 +1,6 @@
import type { Generated } from "kysely"; import type { Generated } from "kysely";
interface ThumbnailTable { export interface ThumbnailTable {
id: Generated<number>; id: Generated<number>;
directory_id: number | null; directory_id: number | null;
file_id: number | null; file_id: number | null;

6
src/lib/server/db/schema/mek.ts
View File

@@ -2,13 +2,13 @@ import type { ColumnType, Generated } from "kysely";
export type MekState = "active" | "retired" | "dead"; export type MekState = "active" | "retired" | "dead";
interface MekTable { export interface MekTable {
user_id: number; user_id: number;
version: number; version: number;
state: MekState; state: MekState;
} }
interface MekLogTable { export interface MekLogTable {
id: Generated<number>; id: Generated<number>;
user_id: number; user_id: number;
master_encryption_key_version: number; master_encryption_key_version: number;
@@ -17,7 +17,7 @@ interface MekLogTable {
action_by: number | null; action_by: number | null;
} }
interface ClientMekTable { export interface ClientMekTable {
user_id: number; user_id: number;
client_id: number; client_id: number;
version: number; version: number;

4
src/lib/server/db/schema/session.ts
View File

@@ -1,6 +1,6 @@
import type { ColumnType, Generated } from "kysely"; import type { ColumnType, Generated } from "kysely";
interface SessionTable { export interface SessionTable {
id: string; id: string;
user_id: number; user_id: number;
client_id: number | null; client_id: number | null;
@@ -10,7 +10,7 @@ interface SessionTable {
last_used_by_agent: string | null; last_used_by_agent: string | null;
} }
interface SessionUpgradeChallengeTable { export interface SessionUpgradeChallengeTable {
id: Generated<number>; id: Generated<number>;
session_id: string; session_id: string;
client_id: number; client_id: number;

2
src/lib/server/db/schema/upload.ts
View File

@@ -1,7 +1,7 @@
import type { Generated } from "kysely"; import type { Generated } from "kysely";
import type { Ciphertext } from "./utils"; import type { Ciphertext } from "./utils";
interface UploadSessionTable { export interface UploadSessionTable {
id: string; id: string;
type: "file" | "thumbnail" | "migration"; type: "file" | "thumbnail" | "migration";
user_id: number; user_id: number;

2
src/lib/server/db/schema/user.ts
View File

@@ -1,6 +1,6 @@
import type { Generated } from "kysely"; import type { Generated } from "kysely";
interface UserTable { export interface UserTable {
id: Generated<number>; id: Generated<number>;
email: string; email: string;
nickname: string; nickname: string;

14
src/trpc/routers/directory.ts
View File

@@ -1,7 +1,7 @@
import { TRPCError } from "@trpc/server"; import { TRPCError } from "@trpc/server";
import { z } from "zod"; import { z } from "zod";
import { DirectoryIdSchema } from "$lib/schemas"; import { DirectoryIdSchema } from "$lib/schemas";
import { FileRepo, IntegrityError } from "$lib/server/db"; import { DirectoryRepo, FileRepo, IntegrityError } from "$lib/server/db";
import { safeUnlink } from "$lib/server/modules/filesystem"; import { safeUnlink } from "$lib/server/modules/filesystem";
import { router, roleProcedure } from "../init.server"; import { router, roleProcedure } from "../init.server";
@@ -14,13 +14,15 @@ const directoryRouter = router({
) )
.query(async ({ ctx, input }) => { .query(async ({ ctx, input }) => {
const directory = const directory =
input.id !== "root" ? await FileRepo.getDirectory(ctx.session.userId, input.id) : undefined; input.id !== "root"
? await DirectoryRepo.getDirectory(ctx.session.userId, input.id)
: undefined;
if (directory === null) { if (directory === null) {
throw new TRPCError({ code: "NOT_FOUND", message: "Invalid directory id" }); throw new TRPCError({ code: "NOT_FOUND", message: "Invalid directory id" });
} }
const [directories, files] = await Promise.all([ const [directories, files] = await Promise.all([
FileRepo.getAllDirectoriesByParent(ctx.session.userId, input.id), DirectoryRepo.getAllDirectoriesByParent(ctx.session.userId, input.id),
FileRepo.getAllFilesByParent(ctx.session.userId, input.id), FileRepo.getAllFilesByParent(ctx.session.userId, input.id),
]); ]);
return { return {
@@ -78,7 +80,7 @@ const directoryRouter = router({
} }
try { try {
await FileRepo.registerDirectory({ await DirectoryRepo.registerDirectory({
parentId: input.parent, parentId: input.parent,
userId: ctx.session.userId, userId: ctx.session.userId,
mekVersion: input.mekVersion, mekVersion: input.mekVersion,
@@ -105,7 +107,7 @@ const directoryRouter = router({
) )
.mutation(async ({ ctx, input }) => { .mutation(async ({ ctx, input }) => {
try { try {
await FileRepo.setDirectoryEncName(ctx.session.userId, input.id, input.dekVersion, { await DirectoryRepo.setDirectoryEncName(ctx.session.userId, input.id, input.dekVersion, {
ciphertext: input.name, ciphertext: input.name,
iv: input.nameIv, iv: input.nameIv,
}); });
@@ -129,7 +131,7 @@ const directoryRouter = router({
) )
.mutation(async ({ ctx, input }) => { .mutation(async ({ ctx, input }) => {
try { try {
const files = await FileRepo.unregisterDirectory(ctx.session.userId, input.id); const files = await DirectoryRepo.unregisterDirectory(ctx.session.userId, input.id);
return { return {
deletedFiles: files.map((file) => { deletedFiles: files.map((file) => {
safeUnlink(file.path); // Intended safeUnlink(file.path); // Intended

108
src/trpc/routers/favorites.ts
View File

@@ -1,15 +1,24 @@
import { TRPCError } from "@trpc/server"; import { TRPCError } from "@trpc/server";
import { z } from "zod"; import { z } from "zod";
import { FileRepo, IntegrityError } from "$lib/server/db"; import { DirectoryRepo, FileRepo, IntegrityError } from "$lib/server/db";
import { router, roleProcedure } from "../init.server"; import { router, roleProcedure } from "../init.server";
const favoritesRouter = router({ const favoritesRouter = router({
get: roleProcedure["activeClient"].query(async ({ ctx }) => { get: roleProcedure["activeClient"].query(async ({ ctx }) => {
const [files, directories] = await Promise.all([ const [directories, files] = await Promise.all([
DirectoryRepo.getAllFavoriteDirectories(ctx.session.userId),
FileRepo.getAllFavoriteFiles(ctx.session.userId), FileRepo.getAllFavoriteFiles(ctx.session.userId),
FileRepo.getAllFavoriteDirectories(ctx.session.userId),
]); ]);
return { return {
directories: directories.map((directory) => ({
id: directory.id,
parent: directory.parentId,
mekVersion: directory.mekVersion,
dek: directory.encDek,
dekVersion: directory.dekVersion,
name: directory.encName.ciphertext,
nameIv: directory.encName.iv,
})),
files: files.map((file) => ({ files: files.map((file) => ({
id: file.id, id: file.id,
parent: file.parentId, parent: file.parentId,
@@ -24,18 +33,51 @@ const favoritesRouter = router({
lastModifiedAt: file.encLastModifiedAt.ciphertext, lastModifiedAt: file.encLastModifiedAt.ciphertext,
lastModifiedAtIv: file.encLastModifiedAt.iv, lastModifiedAtIv: file.encLastModifiedAt.iv,
})), })),
directories: directories.map((directory) => ({
id: directory.id,
parent: directory.parentId,
mekVersion: directory.mekVersion,
dek: directory.encDek,
dekVersion: directory.dekVersion,
name: directory.encName.ciphertext,
nameIv: directory.encName.iv,
})),
}; };
}), }),
addDirectory: roleProcedure["activeClient"]
.input(
z.object({
id: z.int().positive(),
}),
)
.mutation(async ({ ctx, input }) => {
try {
await DirectoryRepo.setDirectoryFavorite(ctx.session.userId, input.id, true);
} catch (e) {
if (e instanceof IntegrityError) {
if (e.message === "Directory not found") {
throw new TRPCError({ code: "NOT_FOUND", message: "Invalid directory id" });
} else if (e.message === "Directory already favorited") {
throw new TRPCError({ code: "BAD_REQUEST", message: e.message });
}
}
throw e;
}
}),
removeDirectory: roleProcedure["activeClient"]
.input(
z.object({
id: z.int().positive(),
}),
)
.mutation(async ({ ctx, input }) => {
try {
await DirectoryRepo.setDirectoryFavorite(ctx.session.userId, input.id, false);
} catch (e) {
if (e instanceof IntegrityError) {
if (e.message === "Directory not found") {
throw new TRPCError({ code: "NOT_FOUND", message: "Invalid directory id" });
} else if (e.message === "Directory not favorited") {
throw new TRPCError({ code: "BAD_REQUEST", message: e.message });
}
}
throw e;
}
}),
addFile: roleProcedure["activeClient"] addFile: roleProcedure["activeClient"]
.input( .input(
z.object({ z.object({
@@ -77,48 +119,6 @@ const favoritesRouter = router({
throw e; throw e;
} }
}), }),
addDirectory: roleProcedure["activeClient"]
.input(
z.object({
id: z.int().positive(),
}),
)
.mutation(async ({ ctx, input }) => {
try {
await FileRepo.setDirectoryFavorite(ctx.session.userId, input.id, true);
} catch (e) {
if (e instanceof IntegrityError) {
if (e.message === "Directory not found") {
throw new TRPCError({ code: "NOT_FOUND", message: "Invalid directory id" });
} else if (e.message === "Directory already favorited") {
throw new TRPCError({ code: "BAD_REQUEST", message: e.message });
}
}
throw e;
}
}),
removeDirectory: roleProcedure["activeClient"]
.input(
z.object({
id: z.int().positive(),
}),
)
.mutation(async ({ ctx, input }) => {
try {
await FileRepo.setDirectoryFavorite(ctx.session.userId, input.id, false);
} catch (e) {
if (e instanceof IntegrityError) {
if (e.message === "Directory not found") {
throw new TRPCError({ code: "NOT_FOUND", message: "Invalid directory id" });
} else if (e.message === "Directory not favorited") {
throw new TRPCError({ code: "BAD_REQUEST", message: e.message });
}
}
throw e;
}
}),
}); });
export default favoritesRouter; export default favoritesRouter;

4
src/trpc/routers/search.ts
View File

@@ -1,6 +1,6 @@
import { z } from "zod"; import { z } from "zod";
import { DirectoryIdSchema } from "$lib/schemas"; import { DirectoryIdSchema } from "$lib/schemas";
import { FileRepo } from "$lib/server/db"; import { DirectoryRepo, FileRepo } from "$lib/server/db";
import { router, roleProcedure } from "../init.server"; import { router, roleProcedure } from "../init.server";
const searchRouter = router({ const searchRouter = router({
@@ -15,7 +15,7 @@ const searchRouter = router({
.query(async ({ ctx, input }) => { .query(async ({ ctx, input }) => {
const [directories, files] = await Promise.all([ const [directories, files] = await Promise.all([
input.includeCategories.length === 0 && input.excludeCategories.length === 0 input.includeCategories.length === 0 && input.excludeCategories.length === 0
? FileRepo.getAllRecursiveDirectoriesByParent(ctx.session.userId, input.ancestor) ? DirectoryRepo.getAllRecursiveDirectoriesByParent(ctx.session.userId, input.ancestor)
: [], : [],
FileRepo.searchFiles(ctx.session.userId, { FileRepo.searchFiles(ctx.session.userId, {
parentId: input.ancestor, parentId: input.ancestor,