Skip to content

armgit / papra

Public Imported from GitHub
0

The minimalistic document archiving platform.

14.6 KB
Raw Blame
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));
}