@v1ct0rbr/minivault-web 0.1.0

package/README.md

@@ -0,0 +1,75 @@
+# minivault-web
+
+Módulo independente de **gestão de backups** (cliente do serviço
+[minivault](../minivault)). Consumível como pacote npm em qualquer app React,
+estilizado com Bootstrap. Comunica-se com a API REST do minivault — normalmente
+através de um **proxy autenticado** (ex.: `/minivault` no backend do Siga+), de
+modo que a `X-API-Key` do minivault jamais trafega no browser.
+
+## Recursos
+
+- Lista de backups com paginação, status, tamanho e data.
+- Criação de backup (com origem de arquivos LOCAL ou S3, opcional).
+- Restauração de backup em um banco informado.
+- Importação de dump SQL em texto (`psql`/`mysql`) via upload.
+- Download e exclusão de backups.
+- Tema claro/escuro e auto-refresh.
+
+## Instalação
+
+```bash
+npm install @v1ct0rbr/minivault-web
+```
+
+Como dependência local durante o desenvolvimento:
+
+```bash
+npm install file:../minivault-web
+```
+
+## Uso no Siga+ (proxy autenticado)
+
+```tsx
+import { MinivaultModule } from '@v1ct0rbr/minivault-web'
+import '@v1ct0rbr/minivault-web/style.css'
+import { useAuthStore } from '@/store/useAuthStore'
+
+const apiBase = import.meta.env.VITE_API_BASE_URL || 'http://localhost:8080'
+
+export function MinivaultPage() {
+  const getToken = () => useAuthStore.getState().token
+  return <MinivaultModule baseUrl={apiBase + '/minivault'} getToken={getToken} />
+}
+```
+
+## Uso standalone (desenvolvimento)
+
+```tsx
+<MinivaultModule baseUrl="http://localhost:8081" token="api-key-do-minivault" />
+```
+
+> Em produção o token do minivault deve ficar apenas no proxy do backend, nunca
+> no bundle do frontend.
+
+## Desenvolvimento
+
+```bash
+npm install
+npm run dev          # playground standalone (porta 5176)
+npm run build:lib    # gera dist/ (lib ES + types)
+npm test             # vitest
+npm run typecheck    # tsc --noEmit
+```
+
+### Playground standalone
+
+```bash
+VITE_MINIVAULT_API_URL=http://localhost:8081 VITE_MINIVAULT_API_TOKEN=chave npm run dev
+```
+
+## Publicação
+
+```bash
+npm run build:lib && npm test
+npm publish --access public
+```

package/dist/api/MinivaultApi.d.ts

@@ -0,0 +1,46 @@
+import { Backup, DatabaseCredentials, DumpOptions, ImportResult, OriginStorageConfig, PageResponse, StorageFileItem, VerifyResult } from '../types/minivault';
+export interface MinivaultApiOptions {
+    /**
+     * URL base da API. Exemplos:
+     *  - Seguir: '/minivault' (proxy autenticado no backend do Siga+)
+     *  - Standalone: 'http://localhost:8081' (minivault direto)
+     */
+    baseUrl: string;
+    /** Token estatico (modo acesso direto a API do minivault). */
+    token?: string;
+    /** Resolvedor dinamico de token (ex.: Keycloak do host). */
+    getToken?: () => string | null | Promise<string | null>;
+    /** Transporte injetavel (padrao: global fetch). */
+    fetch?: typeof fetch;
+    timeoutMs?: number;
+}
+export declare class MinivaultApiError extends Error {
+    readonly status: number;
+    readonly body?: string;
+    constructor(message: string, status: number, body?: string);
+}
+/**
+ * Cliente tipado da API do minivault (gerenciamento de backups).
+ */
+export declare class MinivaultApi {
+    private readonly baseUrl;
+    private readonly token?;
+    private readonly getToken?;
+    private readonly fetchFn;
+    private readonly timeoutMs;
+    constructor(options: MinivaultApiOptions);
+    private resolveToken;
+    private request;
+    listBackups(page?: number, size?: number): Promise<PageResponse<Backup>>;
+    getBackup(id: number): Promise<Backup>;
+    createBackup(database: DatabaseCredentials, originStorage?: OriginStorageConfig, dumpOptions?: DumpOptions): Promise<Backup>;
+    restoreBackup(id: number, database: DatabaseCredentials, originStorage?: OriginStorageConfig): Promise<void>;
+    deleteBackup(id: number): Promise<void>;
+    verifyBackup(id: number): Promise<VerifyResult>;
+    downloadBackup(id: number): Promise<Blob>;
+    importDump(file: File, database: DatabaseCredentials): Promise<ImportResult>;
+    importFromStorage(storageType: string, storagePath: string, database: DatabaseCredentials, storageConfig?: OriginStorageConfig): Promise<ImportResult>;
+    listStorageFiles(type: string, prefix?: string, storageConfig?: OriginStorageConfig): Promise<StorageFileItem[]>;
+    downloadStorageFile(key: string, type: string, storageConfig?: OriginStorageConfig): Promise<Blob>;
+    deleteStorageFile(key: string, type: string, storageConfig?: OriginStorageConfig): Promise<void>;
+}

package/dist/components/BackupsTab.d.ts

@@ -0,0 +1 @@
+export declare function BackupsTab(): import("react").JSX.Element;

package/dist/components/CreateBackupTab.d.ts

@@ -0,0 +1 @@
+export declare function CreateBackupTab(): import("react").JSX.Element;

package/dist/components/CredentialsFields.d.ts

@@ -0,0 +1,8 @@
+import { DatabaseCredentials } from '../types/minivault';
+export declare function defaultPort(type: string): number;
+export interface CredentialsFieldsProps {
+    value?: Partial<DatabaseCredentials>;
+    onChange: (value: DatabaseCredentials) => void;
+    onValidatedChange?: (valid: boolean) => void;
+}
+export declare function CredentialsFields({ value, onChange, onValidatedChange }: CredentialsFieldsProps): import("react").JSX.Element;

package/dist/components/ImportDumpTab.d.ts

@@ -0,0 +1 @@
+export declare function ImportDumpTab(): import("react").JSX.Element;

package/dist/components/MinivaultApiProvider.d.ts

@@ -0,0 +1,8 @@
+import { ReactNode } from 'react';
+import { MinivaultApi, MinivaultApiOptions } from '../api/MinivaultApi';
+export interface MinivaultApiProviderProps extends MinivaultApiOptions {
+    children: ReactNode;
+}
+export declare function MinivaultApiProvider({ children, ...options }: MinivaultApiProviderProps): import("react").JSX.Element;
+export declare function useMinivaultApi(): MinivaultApi;
+export declare function useMinivaultApiOrNull(): MinivaultApi | null;

package/dist/components/MinivaultModule.d.ts

@@ -0,0 +1,8 @@
+import { MinivaultApiProviderProps } from './MinivaultApiProvider';
+export interface MinivaultModuleProps extends Omit<MinivaultApiProviderProps, 'children'> {
+    theme?: 'light' | 'dark';
+    refetchIntervalMs?: number;
+    companyAcronym?: string;
+    storageType?: string;
+}
+export declare function MinivaultModule(props: MinivaultModuleProps): import("react").JSX.Element;

package/dist/components/RestoreModal.d.ts

@@ -0,0 +1,7 @@
+import { Backup } from '../types/minivault';
+export interface RestoreModalProps {
+    backup: Backup;
+    onClose: () => void;
+}
+export declare function RestoreModal({ backup, onClose }: RestoreModalProps): import("react").JSX.Element;
+export declare function messageText(error: unknown): string;

package/dist/components/StatusBadge.d.ts

@@ -0,0 +1,5 @@
+import { BackupStatus } from '../types/minivault';
+export interface StatusBadgeProps {
+    status: BackupStatus;
+}
+export declare function StatusBadge({ status }: StatusBadgeProps): import("react").JSX.Element;

package/dist/components/StorageExplorerTab.d.ts

@@ -0,0 +1,7 @@
+import { OriginStorageConfig } from '../types/minivault';
+interface StorageExplorerTabProps {
+    storageType?: string;
+    storageConfig?: OriginStorageConfig;
+}
+export declare function StorageExplorerTab({ storageType, storageConfig }: StorageExplorerTabProps): import("react").JSX.Element;
+export {};

package/dist/hooks/useBackups.d.ts

@@ -0,0 +1,31 @@
+import { DatabaseCredentials, DumpOptions, OriginStorageConfig } from '../types/minivault';
+export declare const backupsKeys: {
+    all: readonly ["minivault", "backups"];
+};
+export declare function useBackups(page?: number, size?: number, enabled?: boolean): import('@tanstack/react-query').UseQueryResult<import('../types/minivault').PageResponse<import('../types/minivault').Backup>, Error>;
+export declare function useCreateBackup(): import('@tanstack/react-query').UseMutationResult<import('../types/minivault').Backup, Error, {
+    database: DatabaseCredentials;
+    originStorage?: OriginStorageConfig;
+    dumpOptions?: DumpOptions;
+}, unknown>;
+export declare function useRestoreBackup(): import('@tanstack/react-query').UseMutationResult<void, Error, {
+    id: number;
+    database: DatabaseCredentials;
+    originStorage?: OriginStorageConfig;
+}, unknown>;
+export declare function useDeleteBackup(): import('@tanstack/react-query').UseMutationResult<void, Error, number, unknown>;
+export declare function useVerifyBackup(): import('@tanstack/react-query').UseMutationResult<import('../types/minivault').VerifyResult, Error, number, unknown>;
+export declare function useDownloadBackup(): import('@tanstack/react-query').UseMutationResult<Blob, Error, {
+    id: number;
+    filename: string;
+}, unknown>;
+export declare function useImportDump(): import('@tanstack/react-query').UseMutationResult<import('../types/minivault').ImportResult, Error, {
+    file: File;
+    database: DatabaseCredentials;
+}, unknown>;
+export declare function useImportFromStorage(): import('@tanstack/react-query').UseMutationResult<import('../types/minivault').ImportResult, Error, {
+    storageType: string;
+    storagePath: string;
+    database: DatabaseCredentials;
+    storageConfig?: OriginStorageConfig;
+}, unknown>;

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export { MinivaultModule } from './components/MinivaultModule';
+export type { MinivaultModuleProps } from './components/MinivaultModule';
+export { MinivaultApiProvider, useMinivaultApi } from './components/MinivaultApiProvider';
+export { MinivaultApi, MinivaultApiError } from './api/MinivaultApi';
+export type { MinivaultApiOptions } from './api/MinivaultApi';
+export { BackupsTab } from './components/BackupsTab';
+export { CreateBackupTab } from './components/CreateBackupTab';
+export { ImportDumpTab } from './components/ImportDumpTab';
+export { StorageExplorerTab } from './components/StorageExplorerTab';
+export { RestoreModal } from './components/RestoreModal';
+export { CredentialsFields } from './components/CredentialsFields';
+export { StatusBadge } from './components/StatusBadge';
+export { useBackups, useCreateBackup, useRestoreBackup, useDeleteBackup, useDownloadBackup, useImportDump, useImportFromStorage, } from './hooks/useBackups';
+export { formatFileSize, formatDate, STATUS_LABELS, STATUS_BADGE, DATABASE_TYPE_LABELS } from './utils/format';
+export type { Backup, BackupRequest, BackupStatus, DatabaseCredentials, DatabaseType, DumpOptions, DumpFormat, ImportResult, ImportFromStorageRequest, OriginStorageConfig, PageResponse, RestoreRequest, StorageFileItem, } from './types/minivault';