Open-source personal finance manager. Self-hosted, privacy-first.
Add categorization rules import/export (#338)
Romulo Gatto272b7d3d7d76
diff --git a/backend/app/api/rules.py b/backend/app/api/rules.pyindex 18924a92..f0fafc6f 100644--- a/backend/app/api/rules.py+++ b/backend/app/api/rules.py@@ -1,6 +1,7 @@import uuidfrom fastapi import APIRouter, Depends, HTTPException, status+from fastapi.responses import JSONResponsefrom sqlalchemy.ext.asyncio import AsyncSessionfrom app.core.database import get_async_session@@ -9,7 +10,14 @@ from app.core.workspace_context import (current_workspace,current_writable_workspace,)-from app.schemas.rule import RuleCreate, RuleCreateResponse, RuleRead, RuleUpdate+from app.schemas.rule import (+ RuleCreate,+ RuleCreateResponse,+ RuleImportRequest,+ RuleImportResponse,+ RuleRead,+ RuleUpdate,+)from app.services import rule_servicefrom app.services.rule_service import DuplicateRuleError@@ -45,6 +53,41 @@ async def create_rule(return response[email protected]("/export")+async def export_rules(+ ctx: WorkspaceContext = Depends(current_workspace),+ session: AsyncSession = Depends(get_async_session),+):+ payload = await rule_service.export_rules(session, ctx.workspace.id)+ return JSONResponse(+ content=payload.model_dump(mode="json"),+ headers={+ "Content-Disposition": 'attachment; filename="securo-categorization-rules.json"',+ },+ )++[email protected]("/import", response_model=RuleImportResponse)+async def import_rules(+ data: RuleImportRequest,+ ctx: WorkspaceContext = Depends(current_writable_workspace),+ session: AsyncSession = Depends(get_async_session),+):+ try:+ return await rule_service.import_rules(+ session,+ ctx.workspace.id,+ ctx.user_id,+ data.payload,+ overwrite=data.overwrite,+ )+ except DuplicateRuleError:+ raise HTTPException(+ status_code=status.HTTP_409_CONFLICT,+ detail="Import would overwrite existing rules. Confirm overwrite to continue.",+ )++@router.patch("/{rule_id}", response_model=RuleRead)async def update_rule(rule_id: uuid.UUID,diff --git a/backend/app/schemas/rule.py b/backend/app/schemas/rule.pyindex 1404ae72..dab995a2 100644--- a/backend/app/schemas/rule.py+++ b/backend/app/schemas/rule.py@@ -51,3 +51,29 @@ class RuleCreateResponse(RuleRead):"""A created rule plus how many existing transactions it just affected."""applied_count: int = 0+++class RuleExportItem(BaseModel):+ name: str+ conditions_op: str = "and"+ conditions: list[RuleCondition]+ actions: list[RuleAction]+ priority: int = 0+ is_active: bool = True+++class RuleExportPayload(BaseModel):+ format: str = "securo-categorization-rules"+ version: int = 1+ rules: list[RuleExportItem]+++class RuleImportRequest(BaseModel):+ payload: RuleExportPayload+ overwrite: bool = False+++class RuleImportResponse(BaseModel):+ imported: int+ skipped: int+ overwritten: intdiff --git a/backend/app/services/rule_service.py b/backend/app/services/rule_service.pyindex 77a0bf44..d8624205 100644--- a/backend/app/services/rule_service.py+++ b/backend/app/services/rule_service.py@@ -2,13 +2,13 @@import uuidfrom typing import Optional-from sqlalchemy import select+from sqlalchemy import delete, selectfrom sqlalchemy.ext.asyncio import AsyncSessionfrom app.models.rule import Rulefrom app.models.category import Categoryfrom app.models.transaction import Transaction-from app.schemas.rule import RuleCreate, RuleUpdate+from app.schemas.rule import RuleCreate, RuleExportPayload, RuleImportResponse, RuleUpdatefrom app.services.rule_engine import evaluate_conditions, apply_rule_actionsfrom app.services.category_service import DEFAULT_CATEGORIES_I18N@@ -757,6 +757,113 @@ async def get_rules(session: AsyncSession, workspace_id: uuid.UUID) -> list[Rulereturn list(result.scalars().all())+++async def export_rules(session: AsyncSession, workspace_id: uuid.UUID) -> RuleExportPayload:+ """Return a portable JSON export of rules for a workspace.++ Category actions are serialized by category name rather than UUID so the+ file can be imported into another instance/workspace that has equivalent+ category names but different database IDs.+ """+ rules = await get_rules(session, workspace_id)+ category_result = await session.execute(+ select(Category).where(Category.workspace_id == workspace_id)+ )+ category_names = {str(cat.id): cat.name for cat in category_result.scalars().all()}++ exported_rules = []+ for rule in rules:+ actions = []+ for action in rule.actions or []:+ if action.get("op") == "set_category":+ category_name = category_names.get(str(action.get("value")))+ if not category_name:+ continue+ actions.append({**action, "value": category_name})+ else:+ actions.append(action)+ exported_rules.append({+ "name": rule.name,+ "conditions_op": rule.conditions_op,+ "conditions": rule.conditions or [],+ "actions": actions,+ "priority": rule.priority,+ "is_active": rule.is_active,+ })+ return RuleExportPayload(rules=exported_rules)+++async def import_rules(+ session: AsyncSession,+ workspace_id: uuid.UUID,+ user_id: uuid.UUID,+ payload: RuleExportPayload,+ overwrite: bool = False,+) -> RuleImportResponse:+ """Import a portable rules payload into a workspace.++ Existing rules are only replaced when the caller explicitly passes+ `overwrite=True`. Rules whose `set_category` target cannot be matched by+ category name are skipped.+ """+ existing = await get_rules(session, workspace_id)+ if existing and not overwrite:+ raise DuplicateRuleError("Import would overwrite existing rules")++ category_result = await session.execute(+ select(Category).where(Category.workspace_id == workspace_id)+ )+ categories_by_name = {cat.name: str(cat.id) for cat in category_result.scalars().all()}++ imported = 0+ skipped = 0+ rules_to_create: list[Rule] = []+ seen_names: set[str] = set()++ for incoming in payload.rules:+ if incoming.name in seen_names:+ skipped += 1+ continue+ seen_names.add(incoming.name)+ resolved_actions = []+ missing_required_reference = False+ for action in incoming.actions:+ action_data = action.model_dump()+ if action_data["op"] == "set_category":+ category_id = categories_by_name.get(str(action_data["value"]))+ if not category_id:+ missing_required_reference = True+ break+ action_data["value"] = category_id+ resolved_actions.append(action_data)+ if missing_required_reference:+ skipped += 1+ continue+ rules_to_create.append(Rule(+ user_id=user_id,+ workspace_id=workspace_id,+ name=incoming.name,+ conditions_op=incoming.conditions_op,+ conditions=[condition.model_dump() for condition in incoming.conditions],+ actions=resolved_actions,+ priority=incoming.priority,+ is_active=incoming.is_active,+ ))++ overwritten = 0+ if overwrite and existing and rules_to_create:+ overwritten = len(existing)+ await session.execute(delete(Rule).where(Rule.workspace_id == workspace_id))++ for rule in rules_to_create:+ session.add(rule)+ imported += 1++ await session.commit()+ return RuleImportResponse(imported=imported, skipped=skipped, overwritten=overwritten)++async def get_rule(session: AsyncSession, rule_id: uuid.UUID, workspace_id: uuid.UUID) -> Optional[Rule]:result = await session.execute(select(Rule).where(Rule.id == rule_id, Rule.workspace_id == workspace_id)diff --git a/backend/tests/test_new_rules_api.py b/backend/tests/test_new_rules_api.pyindex 7b7665a9..9357a4ed 100644--- a/backend/tests/test_new_rules_api.py+++ b/backend/tests/test_new_rules_api.py@@ -396,3 +396,121 @@ async def test_rule_user_isolation(items = response.json()["items"]# Verify user1 still has transactionsassert len(items) >= 5+++async def test_export_rules_serializes_category_actions_by_name(client: AsyncClient, auth_headers, test_rules, test_categories):+ response = await client.get("/api/rules/export", headers=auth_headers)++ assert response.status_code == 200+ assert response.headers["content-type"].startswith("application/json")+ assert response.headers["content-disposition"].startswith("attachment;")+ payload = response.json()+ assert payload["format"] == "securo-categorization-rules"+ assert payload["version"] == 1+ exported = {rule["name"]: rule for rule in payload["rules"]}+ assert set(exported) == {"UBER rule", "IFOOD rule", "SALARIO rule"}+ uber_action = exported["UBER rule"]["actions"][0]+ assert uber_action == {"op": "set_category", "value": "Transporte"}+ assert "id" not in exported["UBER rule"]+ assert "user_id" not in exported["UBER rule"]+++async def test_import_rules_requires_overwrite_confirmation_when_rules_exist(+ client: AsyncClient, auth_headers, test_rules, test_categories+):+ payload = {+ "format": "securo-categorization-rules",+ "version": 1,+ "rules": [+ {+ "name": "Imported Netflix",+ "conditions_op": "and",+ "conditions": [{"field": "description", "op": "contains", "value": "NETFLIX"}],+ "actions": [{"op": "set_category", "value": "Alimentação"}],+ "priority": 7,+ "is_active": True,+ }+ ],+ }++ response = await client.post("/api/rules/import", json={"payload": payload}, headers=auth_headers)++ assert response.status_code == 409+ assert "overwrite" in response.json()["detail"].lower()+++async def test_import_rules_overwrites_existing_rules_and_maps_categories_by_name(+ client: AsyncClient, auth_headers, test_rules, test_categories+):+ payload = {+ "format": "securo-categorization-rules",+ "version": 1,+ "rules": [+ {+ "name": "Imported Netflix",+ "conditions_op": "and",+ "conditions": [{"field": "description", "op": "contains", "value": "NETFLIX"}],+ "actions": [{"op": "set_category", "value": "Alimentação"}],+ "priority": 7,+ "is_active": True,+ },+ {+ "name": "Missing category rule",+ "conditions_op": "and",+ "conditions": [{"field": "description", "op": "contains", "value": "UNKNOWN"}],+ "actions": [{"op": "set_category", "value": "Does Not Exist"}],+ "priority": 8,+ "is_active": True,+ },+ ],+ }++ response = await client.post(+ "/api/rules/import",+ json={"payload": payload, "overwrite": True},+ headers=auth_headers,+ )++ assert response.status_code == 200+ assert response.json() == {"imported": 1, "skipped": 1, "overwritten": 3}+ rules_response = await client.get("/api/rules", headers=auth_headers)+ rules = rules_response.json()+ assert [r["name"] for r in rules] == ["Imported Netflix"]+ assert rules[0]["actions"] == [{"op": "set_category", "value": str(test_categories[0].id)}]+++async def test_import_rules_with_overwrite_preserves_existing_when_every_rule_is_skipped(+ client: AsyncClient, auth_headers, test_rules+):+ payload = {+ "format": "securo-categorization-rules",+ "version": 1,+ "rules": [+ {+ "name": "External groceries rule",+ "conditions_op": "and",+ "conditions": [{"field": "description", "op": "contains", "value": "MARKET"}],+ "actions": [{"op": "set_category", "value": "Groceries"}],+ "priority": 7,+ "is_active": True,+ }+ ],+ }++ before_response = await client.get("/api/rules", headers=auth_headers)+ before_names = [rule["name"] for rule in before_response.json()]++ response = await client.post(+ "/api/rules/import",+ json={"payload": payload, "overwrite": True},+ headers=auth_headers,+ )++ assert response.status_code == 200+ assert response.json() == {"imported": 0, "skipped": 1, "overwritten": 0}+ after_response = await client.get("/api/rules", headers=auth_headers)+ assert [rule["name"] for rule in after_response.json()] == before_namesdiff --git a/docs/rules-export-import-toolbar.png b/docs/rules-export-import-toolbar.pngnew file mode 100644index 00000000..3b49120eBinary files /dev/null and b/docs/rules-export-import-toolbar.png differdiff --git a/docs/rules-import-overwrite-confirmation.png b/docs/rules-import-overwrite-confirmation.pngnew file mode 100644index 00000000..e6999e1dBinary files /dev/null and b/docs/rules-import-overwrite-confirmation.png differdiff --git a/frontend/src/lib/api.ts b/frontend/src/lib/api.tsindex c967fe85..a6785a84 100644--- a/frontend/src/lib/api.ts+++ b/frontend/src/lib/api.ts@@ -23,6 +23,8 @@ import type {Budget,BudgetVsActual,Rule,+ RuleExportPayload,+ RuleImportResponse,ImportLog,ImportPreviewTransaction,Workspace,@@ -803,6 +805,22 @@ export const rules = {const { data } = await api.post('/rules/apply-all')return data},+ exportFile: async (): Promise<void> => {+ const { data } = await api.get('/rules/export', { responseType: 'blob' })+ const blob = new Blob([data], { type: 'application/json;charset=utf-8;' })+ const url = URL.createObjectURL(blob)+ const a = document.createElement('a')+ a.href = url+ a.download = `securo-categorization-rules-${new Date().toISOString().slice(0, 10)}.json`+ document.body.appendChild(a)+ a.click()+ document.body.removeChild(a)+ URL.revokeObjectURL(url)+ },+ importFile: async (payload: RuleExportPayload, overwrite = false): Promise<RuleImportResponse> => {+ const { data } = await api.post('/rules/import', { payload, overwrite })+ return data+ },packs: async (): Promise<{ code: string; name: string; flag: string; rule_count: number; installed: boolean }[]> => {const { data } = await api.get('/rules/packs')return datadiff --git a/frontend/src/locales/en.json b/frontend/src/locales/en.jsonindex c7dba952..76082a79 100644--- a/frontend/src/locales/en.json+++ b/frontend/src/locales/en.json@@ -789,7 +789,16 @@"sortLabel": "Sort by","sortBy_priority": "Priority","sortBy_name": "Name",- "sortBy_category": "Category"+ "sortBy_category": "Category",+ "export": "Export",+ "import": "Import",+ "exported": "Rules export downloaded",+ "imported": "Imported {{imported}} rules ({{skipped}} skipped)",+ "invalidImportFile": "Invalid rules import file",+ "importConfirmTitle": "Import categorization rules?",+ "importConfirmDescription": "File {{file}} contains {{count}} rules.",+ "importOverwriteWarning": "Importing will overwrite your current categorization rules. This cannot be undone.",+ "confirmOverwriteImport": "Overwrite and import"},"categories": {"title": "Categories",diff --git a/frontend/src/locales/es.json b/frontend/src/locales/es.jsonindex 0946e547..5fe4afeb 100644--- a/frontend/src/locales/es.json+++ b/frontend/src/locales/es.json@@ -789,7 +789,16 @@"sortLabel": "Ordenar por","sortBy_priority": "Prioridad","sortBy_name": "Nombre",- "sortBy_category": "Categoría"+ "sortBy_category": "Categoría",+ "export": "Export",+ "import": "Import",+ "exported": "Rules export downloaded",+ "imported": "Imported {{imported}} rules ({{skipped}} skipped)",+ "invalidImportFile": "Invalid rules import file",+ "importConfirmTitle": "Import categorization rules?",+ "importConfirmDescription": "File {{file}} contains {{count}} rules.",+ "importOverwriteWarning": "Importing will overwrite your current categorization rules. This cannot be undone.",+ "confirmOverwriteImport": "Overwrite and import"},"categories": {"title": "Categorías",diff --git a/frontend/src/locales/it.json b/frontend/src/locales/it.jsonindex fdadb4dd..7595712b 100644--- a/frontend/src/locales/it.json+++ b/frontend/src/locales/it.json@@ -789,7 +789,16 @@"sortLabel": "Ordina per","sortBy_priority": "Priorità","sortBy_name": "Nome",- "sortBy_category": "Categoria"+ "sortBy_category": "Categoria",+ "export": "Export",+ "import": "Import",+ "exported": "Rules export downloaded",+ "imported": "Imported {{imported}} rules ({{skipped}} skipped)",+ "invalidImportFile": "Invalid rules import file",+ "importConfirmTitle": "Import categorization rules?",+ "importConfirmDescription": "File {{file}} contains {{count}} rules.",+ "importOverwriteWarning": "Importing will overwrite your current categorization rules. This cannot be undone.",+ "confirmOverwriteImport": "Overwrite and import"},"categories": {"title": "Categorie",diff --git a/frontend/src/locales/pl.json b/frontend/src/locales/pl.jsonindex 99d18ac9..db185d23 100644--- a/frontend/src/locales/pl.json+++ b/frontend/src/locales/pl.json@@ -843,7 +843,16 @@"sortLabel": "Sortuj wg","sortBy_priority": "Priorytet","sortBy_name": "Nazwa",- "sortBy_category": "Kategoria"+ "sortBy_category": "Kategoria",+ "export": "Export",+ "import": "Import",+ "exported": "Rules export downloaded",+ "imported": "Imported {{imported}} rules ({{skipped}} skipped)",+ "invalidImportFile": "Invalid rules import file",+ "importConfirmTitle": "Import categorization rules?",+ "importConfirmDescription": "File {{file}} contains {{count}} rules.",+ "importOverwriteWarning": "Importing will overwrite your current categorization rules. This cannot be undone.",+ "confirmOverwriteImport": "Overwrite and import"},"categories": {"title": "Kategorie",diff --git a/frontend/src/locales/pt-BR.json b/frontend/src/locales/pt-BR.jsonindex febe008a..f792047c 100644--- a/frontend/src/locales/pt-BR.json+++ b/frontend/src/locales/pt-BR.json@@ -789,7 +789,16 @@"sortLabel": "Ordenar por","sortBy_priority": "Prioridade","sortBy_name": "Nome",- "sortBy_category": "Categoria"+ "sortBy_category": "Categoria",+ "export": "Export",+ "import": "Import",+ "exported": "Rules export downloaded",+ "imported": "Imported {{imported}} rules ({{skipped}} skipped)",+ "invalidImportFile": "Invalid rules import file",+ "importConfirmTitle": "Import categorization rules?",+ "importConfirmDescription": "File {{file}} contains {{count}} rules.",+ "importOverwriteWarning": "Importing will overwrite your current categorization rules. This cannot be undone.",+ "confirmOverwriteImport": "Overwrite and import"},"categories": {"title": "Categorias",diff --git a/frontend/src/pages/rules.tsx b/frontend/src/pages/rules.tsxindex 41a6637b..59389bd9 100644--- a/frontend/src/pages/rules.tsx+++ b/frontend/src/pages/rules.tsx@@ -1,4 +1,4 @@-import { useState, useMemo } from 'react'+import { useRef, useState, useMemo } from 'react'import { useTranslation } from 'react-i18next'import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'import { categories as categoriesApi, categoryGroups as categoryGroupsApi, rules as rulesApi, accounts as accountsApi, payees as payeesApi } from '@/lib/api'@@ -12,8 +12,8 @@ import {DialogHeader,DialogTitle,} from '@/components/ui/dialog'-import type { Category, Payee, Rule, RuleAction, RuleCondition } from '@/types'-import { Trash2, Plus, RefreshCw, Package, Check, ArrowUpDown, ArrowUp, ArrowDown } from 'lucide-react'+import type { Category, Payee, Rule, RuleAction, RuleCondition, RuleExportPayload } from '@/types'+import { Trash2, Plus, RefreshCw, Package, Check, ArrowUpDown, ArrowUp, ArrowDown, Download, Upload } from 'lucide-react'import { cn } from '@/lib/utils'import { PageHeader } from '@/components/page-header'import { useWorkspace } from '@/contexts/workspace-context'@@ -116,6 +116,10 @@ export default function RulesPage() {const { canWrite } = useWorkspace()const [dialogOpen, setDialogOpen] = useState(false)const [packsDialogOpen, setPacksDialogOpen] = useState(false)+ const [importDialogOpen, setImportDialogOpen] = useState(false)+ const [pendingImport, setPendingImport] = useState<RuleExportPayload | null>(null)+ const [pendingImportName, setPendingImportName] = useState('')+ const importInputRef = useRef<HTMLInputElement | null>(null)const [editing, setEditing] = useState<Rule | null>(null)// Bumped on every open so the dialog remounts with fresh state instead of// retaining the previously entered rule (issue #306).@@ -221,8 +225,44 @@ export default function RulesPage() {onError: () => toast.error(t('common.error')),})- const categories = categoriesList ?? []- const payees = payeesList ?? []+ const exportMutation = useMutation({+ mutationFn: () => rulesApi.exportFile(),+ onSuccess: () => toast.success(t('rules.exported')),+ onError: () => toast.error(t('common.error')),+ })++ const importMutation = useMutation({+ mutationFn: (payload: RuleExportPayload) => rulesApi.importFile(payload, true),+ onSuccess: (data) => {+ queryClient.invalidateQueries({ queryKey: ['rules'] })+ queryClient.invalidateQueries({ queryKey: ['rule-packs'] })+ setImportDialogOpen(false)+ setPendingImport(null)+ setPendingImportName('')+ toast.success(t('rules.imported', { imported: data.imported, skipped: data.skipped }))+ },+ onError: () => toast.error(t('common.error')),+ })++ async function handleImportFile(file: File) {+ try {+ const parsed = JSON.parse(await file.text()) as RuleExportPayload+ if (parsed.format !== 'securo-categorization-rules' || !Array.isArray(parsed.rules)) {+ toast.error(t('rules.invalidImportFile'))+ return+ }+ setPendingImport(parsed)+ setPendingImportName(file.name)+ setImportDialogOpen(true)+ } catch {+ toast.error(t('rules.invalidImportFile'))+ } finally {+ if (importInputRef.current) importInputRef.current.value = ''+ }+ }++ const categories = useMemo(() => categoriesList ?? [], [categoriesList])+ const payees = useMemo(() => payeesList ?? [], [payeesList])const [sortBy, setSortBy] = useState<'priority' | 'name' | 'category'>('priority')const [sortDir, setSortDir] = useState<'asc' | 'desc'>('asc')@@ -255,6 +295,36 @@ export default function RulesPage() {action={canWrite ? (<div className="flex gap-2">+ <input+ ref={importInputRef}+ type="file"+ accept="application/json,.json"+ className="hidden"+ onChange={(event) => {+ const file = event.target.files?.[0]+ if (file) void handleImportFile(file)+ }}+ />+ <Button+ variant="outline"+ size="sm"+ className="gap-1.5 h-8"+ onClick={() => exportMutation.mutate()}+ disabled={exportMutation.isPending}+ >+ <Download size={12} />+ <span className="hidden sm:inline">{t('rules.export')}</span>+ </Button>+ <Button+ variant="outline"+ size="sm"+ className="gap-1.5 h-8"+ onClick={() => importInputRef.current?.click()}+ disabled={importMutation.isPending}+ >+ <Upload size={12} />+ <span className="hidden sm:inline">{t('rules.import')}</span>+ </Button><Buttonvariant="outline"size="sm"@@ -360,6 +430,36 @@ export default function RulesPage() {onClose={() => setPacksDialogOpen(false)}/>+ <Dialog open={importDialogOpen} onOpenChange={setImportDialogOpen}>+ <DialogContent className="max-w-md">+ <DialogHeader>+ <DialogTitle>{t('rules.importConfirmTitle')}</DialogTitle>+ </DialogHeader>+ <div className="space-y-3 text-sm text-muted-foreground">+ <p>{t('rules.importConfirmDescription', { count: pendingImport?.rules.length ?? 0, file: pendingImportName })}</p>+ <p className="font-medium text-amber-600">{t('rules.importOverwriteWarning')}</p>+ </div>+ <div className="flex justify-end gap-2 pt-2">+ <Button+ type="button"+ variant="outline"+ onClick={() => { setImportDialogOpen(false); setPendingImport(null); setPendingImportName('') }}+ disabled={importMutation.isPending}+ >+ {t('common.cancel')}+ </Button>+ <Button+ type="button"+ variant="destructive"+ onClick={() => { if (pendingImport) importMutation.mutate(pendingImport) }}+ disabled={!pendingImport || importMutation.isPending}+ >+ {t('rules.confirmOverwriteImport')}+ </Button>+ </div>+ </DialogContent>+ </Dialog>+<RuleDialogkey={dialogInstance}open={dialogOpen}diff --git a/frontend/src/types/index.ts b/frontend/src/types/index.tsindex 8b7b1125..8ca083c0 100644--- a/frontend/src/types/index.ts+++ b/frontend/src/types/index.ts@@ -356,6 +356,27 @@ export interface Rule {is_active: boolean}+export interface RuleExportItem {+ name: string+ conditions_op: 'and' | 'or'+ conditions: RuleCondition[]+ actions: RuleAction[]+ priority: number+ is_active: boolean+}++export interface RuleExportPayload {+ format: 'securo-categorization-rules'+ version: number+ rules: RuleExportItem[]+}++export interface RuleImportResponse {+ imported: number+ skipped: number+ overwritten: number+}+export interface ImportLog {id: stringuser_id: string