The minimalistic document archiving platform.
import type { Database } from '../app/database/database.types';
import type { DbInsertableDocument } from './documents.types';
import { injectArguments, safely } from '@corentinth/chisels';
import { and, count, desc, eq, inArray, lt, sql } from 'drizzle-orm';
import { createIterator } from '../app/database/database.usecases';
import { createOrganizationNotFoundError } from '../organizations/organizations.errors';
import { chunkArray } from '../shared/arrays/arrays.utils';
import { subDays } from '../shared/date';
import { isUniqueConstraintError } from '../shared/db/constraints.models';
import { withPagination } from '../shared/db/pagination';
import { createError } from '../shared/errors/errors';
import { omitUndefined } from '../shared/objects';
import { isDefined, isNil, uniq } from '../shared/utils';
import { createDocumentAlreadyExistsError, createDocumentNotFoundError } from './documents.errors';
import { documentsTable } from './documents.table';
export type DocumentsRepository = ReturnType<typeof createDocumentsRepository>;
export function createDocumentsRepository({ db }: { db: Database }) {
return injectArguments(
{
saveOrganizationDocument,
getOrganizationDeletedDocuments,
getDocumentById,
softDeleteDocument,
softDeleteDocuments,
getOrganizationDeletedDocumentsCount,
restoreDocument,
hardDeleteDocument,
getExpiredDeletedDocuments,
getOrganizationStats,
getOrganizationDocumentBySha256Hash,
getAllOrganizationTrashDocuments,
getAllOrganizationDocuments,
getAllOrganizationDocumentsIterator,
getAllOrganizationUndeletedDocumentsIterator,
updateDocument,
updateDocumentStorageKey,
getGlobalDocumentsStats,
areAllDocumentsInOrganization,
},
{ db },
);
}
async function getOrganizationDocumentBySha256Hash({
sha256Hash,
organizationId,
db,
}: {
sha256Hash: string;
organizationId: string;
db: Database;
}) {
const [document] = await db
.select()
.from(documentsTable)
.where(
and(
eq(documentsTable.originalSha256Hash, sha256Hash),
eq(documentsTable.organizationId, organizationId),
),
);
return { document };
}
async function saveOrganizationDocument({
db,
...documentToInsert
}: { db: Database } & DbInsertableDocument) {
const [documents, error] = await safely(
db.insert(documentsTable).values(documentToInsert).returning(),
);
if (isUniqueConstraintError({ error })) {
throw createDocumentAlreadyExistsError();
}
if (error) {
throw error;
}
const [document] = documents ?? [];
if (isNil(document)) {
// Very unlikely to happen as the insertion throws an issue, it's for type safety
throw createError({
message: 'Error while saving document',
code: 'documents.save_error',
statusCode: 500,
isInternal: true,
});
}
return { document };
}
async function getOrganizationDeletedDocumentsCount({
organizationId,
db,
}: {
organizationId: string;
db: Database;
}) {
const [record] = await db
.select({
documentsCount: count(documentsTable.id),
})
.from(documentsTable)
.where(
and(eq(documentsTable.organizationId, organizationId), eq(documentsTable.isDeleted, true)),
);
if (isNil(record)) {
throw createOrganizationNotFoundError();
}
const { documentsCount } = record;
return { documentsCount };
}
async function getOrganizationDeletedDocuments({
organizationId,
pageIndex,
pageSize,
db,
}: {
organizationId: string;
pageIndex: number;
pageSize: number;
db: Database;
}) {
const query = db
.select()
.from(documentsTable)
.where(
and(eq(documentsTable.organizationId, organizationId), eq(documentsTable.isDeleted, true)),
);
const documents = await withPagination(query.$dynamic(), {
orderByColumn: desc(documentsTable.deletedAt),
pageIndex,
pageSize,
});
return {
documents,
};
}
async function getDocumentById({
documentId,
organizationId,
db,
}: {
documentId: string;
organizationId: string;
db: Database;
}) {
const [document] = await db
.select()
.from(documentsTable)
.where(
and(eq(documentsTable.id, documentId), eq(documentsTable.organizationId, organizationId)),
);
return { document };
}
async function softDeleteDocument({
documentId,
organizationId,
userId,
db,
now = new Date(),
}: {
documentId: string;
organizationId: string;
userId: string;
db: Database;
now?: Date;
}) {
await db
.update(documentsTable)
.set({
isDeleted: true,
deletedBy: userId,
deletedAt: now,
})
.where(
and(eq(documentsTable.id, documentId), eq(documentsTable.organizationId, organizationId)),
);
}
// Chunked to stay safely under SQLite's host parameter limit (default 32766)
// when the documentIds list is large (e.g. resolved from a search query).
const SOFT_DELETE_CHUNK_SIZE = 500;
async function softDeleteDocuments({
documentIds,
organizationId,
userId,
db,
now = new Date(),
}: {
documentIds: string[];
organizationId: string;
userId: string;
db: Database;
now?: Date;
}) {
if (documentIds.length === 0) {
return { trashedDocumentIds: [] };
}
const trashedDocumentIds: string[] = [];
const chunks = chunkArray(documentIds, SOFT_DELETE_CHUNK_SIZE);
for (const idsChunk of chunks) {
const rows = await db
.update(documentsTable)
.set({
isDeleted: true,
deletedBy: userId,
deletedAt: now,
})
.where(
and(
inArray(documentsTable.id, idsChunk),
eq(documentsTable.organizationId, organizationId),
eq(documentsTable.isDeleted, false),
),
)
.returning({ id: documentsTable.id });
trashedDocumentIds.push(...rows.map((row) => row.id));
}
return { trashedDocumentIds };
}
async function restoreDocument({
documentId,
organizationId,
name,
userId,
db,
}: {
documentId: string;
organizationId: string;
name?: string;
userId?: string;
db: Database;
}) {
const [document] = await db
.update(documentsTable)
.set({
isDeleted: false,
deletedBy: null,
deletedAt: null,
...(isDefined(name) ? { name, originalName: name } : {}),
...(isDefined(userId) ? { createdBy: userId } : {}),
})
.where(
and(eq(documentsTable.id, documentId), eq(documentsTable.organizationId, organizationId)),
)
.returning();
if (isNil(document)) {
throw createDocumentNotFoundError();
}
return { document };
}
async function hardDeleteDocument({ documentId, db }: { documentId: string; db: Database }) {
await db.delete(documentsTable).where(eq(documentsTable.id, documentId));
}
async function getExpiredDeletedDocuments({
db,
expirationDelayInDays,
now = new Date(),
}: {
db: Database;
expirationDelayInDays: number;
now?: Date;
}) {
const expirationDate = subDays(now, expirationDelayInDays);
const documents = await db
.select({
id: documentsTable.id,
originalStorageKey: documentsTable.originalStorageKey,
organizationId: documentsTable.organizationId,
})
.from(documentsTable)
.where(and(eq(documentsTable.isDeleted, true), lt(documentsTable.deletedAt, expirationDate)));
return {
documents,
};
}
async function getOrganizationStats({
organizationId,
db,
}: {
organizationId: string;
db: Database;
}) {
const [record] = await db
.select({
totalDocumentsCount: count(documentsTable.id),
totalDocumentsSize: sql<number>`COALESCE(SUM(${documentsTable.originalSize}), 0)`.as(
'totalDocumentsSize',
),
deletedDocumentsCount:
sql<number>`COUNT(${documentsTable.id}) FILTER (WHERE ${documentsTable.isDeleted} = true)`.as(
'deletedDocumentsCount',
),
documentsCount:
sql<number>`COUNT(${documentsTable.id}) FILTER (WHERE ${documentsTable.isDeleted} = false)`.as(
'documentsCount',
),
documentsSize:
sql<number>`COALESCE(SUM(${documentsTable.originalSize}) FILTER (WHERE ${documentsTable.isDeleted} = false), 0)`.as(
'documentsSize',
),
deletedDocumentsSize:
sql<number>`COALESCE(SUM(${documentsTable.originalSize}) FILTER (WHERE ${documentsTable.isDeleted} = true), 0)`.as(
'deletedDocumentsSize',
),
})
.from(documentsTable)
.where(and(eq(documentsTable.organizationId, organizationId)));
if (isNil(record)) {
throw createOrganizationNotFoundError();
}
const {
documentsCount,
documentsSize,
deletedDocumentsCount,
deletedDocumentsSize,
totalDocumentsCount,
totalDocumentsSize,
} = record;
return {
documentsCount,
documentsSize: Number(documentsSize ?? 0),
deletedDocumentsCount,
deletedDocumentsSize,
totalDocumentsCount,
totalDocumentsSize,
};
}
async function getAllOrganizationTrashDocuments({
organizationId,
db,
}: {
organizationId: string;
db: Database;
}) {
const documents = await db
.select({
id: documentsTable.id,
originalStorageKey: documentsTable.originalStorageKey,
organizationId: documentsTable.organizationId,
})
.from(documentsTable)
.where(
and(eq(documentsTable.organizationId, organizationId), eq(documentsTable.isDeleted, true)),
);
return {
documents,
};
}
async function getAllOrganizationDocuments({
organizationId,
db,
}: {
organizationId: string;
db: Database;
}) {
const documents = await db
.select({
id: documentsTable.id,
originalStorageKey: documentsTable.originalStorageKey,
})
.from(documentsTable)
.where(eq(documentsTable.organizationId, organizationId));
return {
documents,
};
}
function getAllOrganizationDocumentsIterator({
organizationId,
batchSize = 100,
db,
}: {
organizationId: string;
batchSize?: number;
db: Database;
}) {
const query = db
.select({
id: documentsTable.id,
originalStorageKey: documentsTable.originalStorageKey,
})
.from(documentsTable)
.where(eq(documentsTable.organizationId, organizationId))
.orderBy(documentsTable.createdAt)
.$dynamic();
return createIterator({ query, batchSize }) as AsyncGenerator<{
id: string;
originalStorageKey: string;
}>;
}
function getAllOrganizationUndeletedDocumentsIterator({
organizationId,
batchSize = 100,
db,
}: {
organizationId: string;
batchSize?: number;
db: Database;
}) {
const query = db
.select()
.from(documentsTable)
.where(
and(eq(documentsTable.organizationId, organizationId), eq(documentsTable.isDeleted, false)),
)
.orderBy(documentsTable.createdAt)
.$dynamic();
return createIterator({ query, batchSize });
}
async function updateDocument({
documentId,
organizationId,
name,
content,
documentDate,
notes,
db,
}: {
documentId: string;
organizationId: string;
name?: string;
content?: string;
documentDate?: Date | null;
notes?: string;
db: Database;
}) {
const [document] = await db
.update(documentsTable)
.set(omitUndefined({ name, content, documentDate, notes }))
.where(
and(eq(documentsTable.id, documentId), eq(documentsTable.organizationId, organizationId)),
)
.returning();
if (isNil(document)) {
throw createDocumentNotFoundError();
}
return { document };
}
async function updateDocumentStorageKey({
documentId,
organizationId,
sourceStorageKey,
storageKey,
name,
updatedAt,
db,
}: {
documentId: string;
organizationId: string;
sourceStorageKey: string;
storageKey: string;
name: string;
updatedAt: Date;
db: Database;
}) {
const rows = await db
.update(documentsTable)
// A storage-only change must not alter the document's modification date.
.set({ originalStorageKey: storageKey, updatedAt })
.where(
and(
eq(documentsTable.id, documentId),
eq(documentsTable.organizationId, organizationId),
eq(documentsTable.originalStorageKey, sourceStorageKey),
eq(documentsTable.name, name),
eq(documentsTable.updatedAt, updatedAt),
eq(documentsTable.isDeleted, false),
),
)
.returning({ id: documentsTable.id });
return { updated: rows.length > 0 };
}
async function getGlobalDocumentsStats({ db }: { db: Database }) {
const [record] = await db
.select({
totalDocumentsCount: count(documentsTable.id),
totalDocumentsSize: sql<number>`COALESCE(SUM(${documentsTable.originalSize}), 0)`.as(
'totalDocumentsSize',
),
deletedDocumentsCount:
sql<number>`COUNT(${documentsTable.id}) FILTER (WHERE ${documentsTable.isDeleted} = true)`.as(
'deletedDocumentsCount',
),
documentsCount:
sql<number>`COUNT(${documentsTable.id}) FILTER (WHERE ${documentsTable.isDeleted} = false)`.as(
'documentsCount',
),
documentsSize:
sql<number>`COALESCE(SUM(${documentsTable.originalSize}) FILTER (WHERE ${documentsTable.isDeleted} = false), 0)`.as(
'documentsSize',
),
deletedDocumentsSize:
sql<number>`COALESCE(SUM(${documentsTable.originalSize}) FILTER (WHERE ${documentsTable.isDeleted} = true), 0)`.as(
'deletedDocumentsSize',
),
})
.from(documentsTable);
if (isNil(record)) {
return {
documentsCount: 0,
documentsSize: 0,
deletedDocumentsCount: 0,
deletedDocumentsSize: 0,
totalDocumentsCount: 0,
totalDocumentsSize: 0,
};
}
const {
documentsCount,
documentsSize,
deletedDocumentsCount,
deletedDocumentsSize,
totalDocumentsCount,
totalDocumentsSize,
} = record;
return {
documentsCount,
documentsSize: Number(documentsSize ?? 0),
deletedDocumentsCount,
deletedDocumentsSize: Number(deletedDocumentsSize ?? 0),
totalDocumentsCount,
totalDocumentsSize: Number(totalDocumentsSize ?? 0),
};
}
export async function areAllDocumentsInOrganization({
documentIds,
organizationId,
db,
}: {
documentIds: string[];
organizationId: string;
db: Database;
}) {
const deduplicatedDocumentIds = uniq(documentIds);
if (deduplicatedDocumentIds.length === 0) {
return true;
}
const documents = await db
.select({ id: documentsTable.id })
.from(documentsTable)
.where(
and(
inArray(documentsTable.id, deduplicatedDocumentIds),
eq(documentsTable.organizationId, organizationId),
),
);
const foundDocumentIds = new Set(documents.map((d) => d.id));
if (foundDocumentIds.size !== deduplicatedDocumentIds.length) {
return false;
}
return documentIds.every((documentId) => foundDocumentIds.has(documentId));
}