appwrite-utils-cli 1.9.6 → 1.11.0

package/dist/shared/migrationHelpers.d.ts

@@ -1,61 +0,0 @@
-import { type Databases } from "node-appwrite";
-import { z } from "zod";
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
-/**
- * Object that contains the context for an action that needs to be executed after import
- * Used in the afterImportActionsDefinitions
- * @type {ContextObject}
- * @typedef {Object} ContextObject
- * @property {string} collectionId - The ID of the collection
- * @property {any} finalItem - The final item that was imported
- * @property {string} action - The name of the action
- * @property {string[]} params - The parameters for the action
- * @property {Object} context - The context object for the action (all the data of this specific item)
- */
-export declare const ContextObject: z.ZodObject<{
-    dbId: z.ZodString;
-    collectionId: z.ZodString;
-    finalItem: z.ZodAny;
-    attributeMappings: z.ZodArray<z.ZodObject<{
-        oldKey: z.ZodOptional<z.ZodString>;
-        oldKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        targetKey: z.ZodString;
-        valueToSet: z.ZodOptional<z.ZodAny>;
-        fileData: z.ZodOptional<z.ZodObject<{
-            name: z.ZodString;
-            path: z.ZodString;
-        }, z.core.$strip>>;
-        converters: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
-        validationActions: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodObject<{
-            action: z.ZodString;
-            params: z.ZodArray<z.ZodString>;
-        }, z.core.$strip>>>>;
-        postImportActions: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodObject<{
-            action: z.ZodString;
-            params: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
-        }, z.core.$strip>>>>;
-    }, z.core.$strip>>;
-    context: z.ZodAny;
-}, z.core.$strip>;
-export type ContextObject = z.infer<typeof ContextObject>;
-export declare const createOrFindAfterImportOperation: (database: Databases, collectionId: string, context: ContextObject) => Promise<void>;
-export declare const addBatch: (database: Databases, data: string) => Promise<string>;
-export declare const getAfterImportOperations: (database: Databases, collectionId: string) => Promise<{
-    $id: string;
-    $createdAt: string;
-    $updatedAt: string;
-    operationType: string;
-    collectionId: string;
-    data: any;
-    progress: number;
-    total: number;
-    error: string;
-    status: "error" | "pending" | "ready" | "in_progress" | "completed" | "cancelled";
-    batches?: string[] | undefined;
-}[]>;
-export declare const findOrCreateOperation: (db: DatabaseAdapter, databaseId: string, operationType: string, collectionId?: string, data?: any) => Promise<any>;
-export declare const updateOperation: (db: DatabaseAdapter, databaseId: string, operationId: string, updates: any) => Promise<any>;
-export declare const getOperation: (db: DatabaseAdapter, databaseId: string, operationId: string) => Promise<any>;
-export declare const maxDataLength = 1073741820;
-export declare const maxBatchItems = 25;
-export declare const splitIntoBatches: (data: any[]) => any[][];

package/dist/shared/migrationHelpers.js

@@ -1,145 +0,0 @@
-import { ID, Query } from "node-appwrite";
-import { BatchSchema, OperationSchema } from "../storage/schemas.js";
-import { AttributeMappingsSchema } from "appwrite-utils";
-import { z } from "zod";
-import { logger } from "./logging.js";
-import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
-import { findOrCreateOperation as findOrCreateOp, updateOperation as updateOp, getOperation as getOp } from "./operationsTable.js";
-import { MessageFormatter } from "./messageFormatter.js";
-/**
- * Object that contains the context for an action that needs to be executed after import
- * Used in the afterImportActionsDefinitions
- * @type {ContextObject}
- * @typedef {Object} ContextObject
- * @property {string} collectionId - The ID of the collection
- * @property {any} finalItem - The final item that was imported
- * @property {string} action - The name of the action
- * @property {string[]} params - The parameters for the action
- * @property {Object} context - The context object for the action (all the data of this specific item)
- */
-export const ContextObject = z.object({
-    dbId: z.string(),
-    collectionId: z.string(),
-    finalItem: z.any(),
-    attributeMappings: AttributeMappingsSchema,
-    context: z.any(),
-});
-export const createOrFindAfterImportOperation = async (database, collectionId, context) => {
-    let operation = await findOrCreateOperationLegacy(database, collectionId, "afterImportAction");
-    if (!operation.batches) {
-        operation.batches = [];
-    }
-    // Directly create a new batch for the context without checking for an existing batch
-    const contextData = JSON.stringify(context);
-    // Create a new batch with the contextData
-    const newBatchId = await addBatch(database, contextData);
-    // Update the operation with the new batch's $id
-    operation.batches = [...operation.batches, newBatchId];
-    await database.updateDocument("migrations", "currentOperations", operation.$id, { batches: operation.batches });
-};
-export const addBatch = async (database, data) => {
-    const batch = await database.createDocument("migrations", "batches", ID.unique(), {
-        data,
-        processed: false,
-    });
-    return batch.$id;
-};
-export const getAfterImportOperations = async (database, collectionId) => {
-    let lastDocumentId;
-    const allOperations = [];
-    let total = 0;
-    do {
-        const query = [
-            Query.equal("collectionId", collectionId),
-            Query.equal("operationType", "afterImportAction"),
-            Query.limit(100),
-        ];
-        if (lastDocumentId) {
-            query.push(Query.cursorAfter(lastDocumentId));
-        }
-        const operations = await database.listDocuments("migrations", "currentOperations", query);
-        total = operations.total; // Update total with the latest fetch
-        allOperations.push(...operations.documents);
-        if (operations.documents.length > 0 && operations.documents.length >= 100) {
-            lastDocumentId =
-                operations.documents[operations.documents.length - 1].$id;
-        }
-    } while (allOperations.length < total);
-    const allOps = allOperations.map((op) => OperationSchema.parse(op));
-    return allOps;
-};
-// Legacy function for backward compatibility with old migrations database
-const findOrCreateOperationLegacy = async (database, collectionId, operationType, additionalQueries) => {
-    const operations = await tryAwaitWithRetry(async () => await database.listDocuments("migrations", "currentOperations", [
-        Query.equal("collectionId", collectionId),
-        Query.equal("operationType", operationType),
-        Query.equal("status", "pending"),
-        ...(additionalQueries || []),
-    ]));
-    if (operations.documents.length > 0) {
-        return OperationSchema.parse(operations.documents[0]);
-    }
-    else {
-        const op = await tryAwaitWithRetry(async () => await database.createDocument("migrations", "currentOperations", ID.unique(), {
-            operationType,
-            collectionId,
-            status: "pending",
-            batches: [],
-            progress: 0,
-            total: 0,
-            error: "",
-        }));
-        return OperationSchema.parse(op);
-    }
-};
-export const findOrCreateOperation = async (db, databaseId, operationType, collectionId, data) => {
-    // Use new operations table system
-    return await findOrCreateOp(db, databaseId, operationType, {
-        targetCollection: collectionId,
-        data: data
-    });
-};
-export const updateOperation = async (db, databaseId, operationId, updates) => {
-    // Use new operations table system
-    return await updateOp(db, databaseId, operationId, updates);
-};
-export const getOperation = async (db, databaseId, operationId) => {
-    // Use new operations table system
-    return await getOp(db, databaseId, operationId);
-};
-// Actual max 1073741824
-export const maxDataLength = 1073741820;
-export const maxBatchItems = 25;
-export const splitIntoBatches = (data) => {
-    let batches = [];
-    let currentBatch = [];
-    let currentBatchLength = 0;
-    let currentBatchItemCount = 0;
-    data.forEach((item, index) => {
-        const itemLength = JSON.stringify(item).length;
-        if (itemLength > maxDataLength) {
-            MessageFormatter.warning(`Large item found at index ${index} with length ${itemLength}`, { prefix: "Batch Splitter" });
-            logger.debug("Large item data:", item);
-        }
-        // Check if adding the current item would exceed the max length or max items per batch
-        if (currentBatchLength + itemLength >= maxDataLength ||
-            currentBatchItemCount >= maxBatchItems) {
-            // If so, start a new batch
-            batches.push(currentBatch);
-            currentBatch = [item];
-            currentBatchLength = itemLength;
-            currentBatchItemCount = 1; // Reset item count for the new batch
-        }
-        else {
-            // Otherwise, add the item to the current batch
-            currentBatch.push(item);
-            currentBatchLength += itemLength;
-            currentBatchItemCount++;
-        }
-    });
-    // Don't forget to add the last batch if it's not empty
-    if (currentBatch.length > 0) {
-        batches.push(currentBatch);
-    }
-    return batches;
-};

package/dist/shared/operationLogger.d.ts

@@ -1,10 +0,0 @@
-import type { Databases, Models } from "node-appwrite";
-import type { OperationCreate } from "../storage/schemas.js";
-/**
- * Legacy operation logger - deprecated
- * This function is maintained for backward compatibility but no longer performs any logging.
- * The operations table system has been refactored to use the dynamic adapter pattern.
- *
- * @deprecated This function will be removed in a future version
- */
-export declare const logOperation: (db: Databases, dbId: string, operationDetails: OperationCreate, operationId?: string) => Promise<Models.Document | null>;

package/dist/shared/operationLogger.js

@@ -1,12 +0,0 @@
-/**
- * Legacy operation logger - deprecated
- * This function is maintained for backward compatibility but no longer performs any logging.
- * The operations table system has been refactored to use the dynamic adapter pattern.
- *
- * @deprecated This function will be removed in a future version
- */
-export const logOperation = async (db, dbId, operationDetails, operationId) => {
-    // No-op: Operations logging has been moved to the new operations table system
-    // Callers should migrate to using operationsTable.ts functions directly
-    return null;
-};

package/dist/shared/operationQueue.d.ts

@@ -1,40 +0,0 @@
-import { type Databases, type Models } from "node-appwrite";
-import type { Attribute } from "appwrite-utils";
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
-export interface QueuedOperation {
-    type: "attribute";
-    collectionId?: string;
-    attribute?: Attribute;
-    collection?: Models.Collection;
-    dependencies?: string[];
-}
-export declare const queuedOperations: QueuedOperation[];
-export declare const nameToIdMapping: Map<string, string>;
-export declare const processedCollections: Set<string>;
-export declare const processedAttributes: Set<string>;
-export declare const enqueueOperation: (operation: QueuedOperation) => void;
-/**
- * Clear all caches and processing state - use between operations
- */
-export declare const clearProcessingState: () => void;
-/**
- * Check if a collection has already been fully processed
- */
-export declare const isCollectionProcessed: (collectionId: string, databaseId: string) => boolean;
-/**
- * Mark a collection as fully processed
- */
-export declare const markCollectionProcessed: (collectionId: string, collectionName: string | undefined, databaseId: string) => void;
-/**
- * Check if a specific attribute has been processed
- */
-export declare const isAttributeProcessed: (databaseId: string, collectionId: string, attributeKey: string) => boolean;
-/**
- * Mark a specific attribute as processed
- */
-export declare const markAttributeProcessed: (databaseId: string, collectionId: string, attributeKey: string) => void;
-/**
- * Process only specific attributes in the queue, not entire collections
- * This prevents triggering full collection re-processing cycles
- */
-export declare const processQueue: (db: Databases | DatabaseAdapter, dbId: string) => Promise<void>;

package/dist/shared/operationQueue.js

@@ -1,311 +0,0 @@
-import { Query } from "node-appwrite";
-import { createOrUpdateAttributeWithStatusCheck } from "../collections/attributes.js";
-import { fetchAndCacheCollectionByName } from "../collections/methods.js";
-import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
-import { logger } from "../shared/logging.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-// Global state management
-export const queuedOperations = [];
-export const nameToIdMapping = new Map();
-// Keys are scoped per database to avoid cross-database collisions
-// Collections key format: `${databaseId}::${collectionId}`
-// Attributes key format: `${databaseId}::${collectionId}::${attributeKey}`
-export const processedCollections = new Set();
-export const processedAttributes = new Set();
-// Helpers to build scoped keys
-const collectionKey = (databaseId, collectionId) => `${databaseId}::${collectionId}`;
-const attributeKeyScoped = (databaseId, collectionId, key) => `${databaseId}::${collectionId}::${key}`;
-export const enqueueOperation = (operation) => {
-    // Avoid duplicate queue entries for same attribute
-    const attributeKey = operation.attribute?.key;
-    const collectionId = operation.collectionId;
-    logger.info('Enqueueing operation', {
-        type: operation.type,
-        attributeKey,
-        collectionId,
-        dependencies: operation.dependencies,
-        queueSizeBefore: queuedOperations.length,
-        operation: 'enqueueOperation'
-    });
-    if (attributeKey && collectionId) {
-        const duplicateIndex = queuedOperations.findIndex((op) => op.collectionId === collectionId && op.attribute?.key === attributeKey);
-        if (duplicateIndex !== -1) {
-            MessageFormatter.info(`Replacing existing queue entry for attribute: ${attributeKey}`);
-            logger.info('Replacing duplicate queue entry', {
-                attributeKey,
-                collectionId,
-                duplicateIndex,
-                operation: 'enqueueOperation'
-            });
-            queuedOperations[duplicateIndex] = operation;
-            return;
-        }
-    }
-    queuedOperations.push(operation);
-    logger.debug('Operation enqueued successfully', {
-        attributeKey,
-        collectionId,
-        queueSizeAfter: queuedOperations.length,
-        operation: 'enqueueOperation'
-    });
-};
-/**
- * Clear all caches and processing state - use between operations
- */
-export const clearProcessingState = () => {
-    const sizeBefore = {
-        collections: processedCollections.size,
-        attributes: processedAttributes.size,
-        nameMapping: nameToIdMapping.size
-    };
-    processedCollections.clear();
-    processedAttributes.clear();
-    nameToIdMapping.clear();
-    logger.debug("Cleared processing state caches", { operation: "clearProcessingState", sizeBefore });
-    logger.info('Processing state cleared', {
-        sizeBefore,
-        operation: 'clearProcessingState'
-    });
-};
-/**
- * Check if a collection has already been fully processed
- */
-export const isCollectionProcessed = (collectionId, databaseId) => {
-    return processedCollections.has(collectionKey(databaseId, collectionId));
-};
-/**
- * Mark a collection as fully processed
- */
-export const markCollectionProcessed = (collectionId, collectionName, databaseId) => {
-    processedCollections.add(collectionKey(databaseId, collectionId));
-    const logData = {
-        databaseId,
-        collectionId,
-        collectionName,
-        totalProcessedCollections: processedCollections.size,
-        operation: 'markCollectionProcessed'
-    };
-    if (collectionName) {
-        MessageFormatter.success(`Marked collection '${collectionName}' (${collectionId}) as processed`, { prefix: 'Tables' });
-    }
-    logger.info('Collection marked as processed', logData);
-};
-/**
- * Check if a specific attribute has been processed
- */
-export const isAttributeProcessed = (databaseId, collectionId, attributeKey) => {
-    return processedAttributes.has(attributeKeyScoped(databaseId, collectionId, attributeKey));
-};
-/**
- * Mark a specific attribute as processed
- */
-export const markAttributeProcessed = (databaseId, collectionId, attributeKey) => {
-    const identifier = attributeKeyScoped(databaseId, collectionId, attributeKey);
-    processedAttributes.add(identifier);
-    logger.debug('Attribute marked as processed', {
-        databaseId,
-        collectionId,
-        attributeKey,
-        identifier,
-        totalProcessedAttributes: processedAttributes.size,
-        operation: 'markAttributeProcessed'
-    });
-};
-/**
- * Process only specific attributes in the queue, not entire collections
- * This prevents triggering full collection re-processing cycles
- */
-export const processQueue = async (db, dbId) => {
-    const startTime = Date.now();
-    if (queuedOperations.length === 0) {
-        MessageFormatter.info("No queued operations to process");
-        logger.info('Queue processing skipped - no operations', {
-            dbId,
-            operation: 'processQueue'
-        });
-        return;
-    }
-    MessageFormatter.section(`Starting surgical queue processing of ${queuedOperations.length} operations for ${dbId}`);
-    logger.info('Starting queue processing', {
-        dbId,
-        queueSize: queuedOperations.length,
-        operations: queuedOperations.map(op => ({
-            type: op.type,
-            attributeKey: op.attribute?.key,
-            collectionId: op.collectionId,
-            dependencies: op.dependencies
-        })),
-        operation: 'processQueue'
-    });
-    let progress = true;
-    let attempts = 0;
-    const maxAttempts = 3; // Prevent infinite loops
-    while (progress && attempts < maxAttempts) {
-        progress = false;
-        attempts++;
-        MessageFormatter.info(`Queue processing attempt ${attempts}/${maxAttempts}`);
-        logger.info('Queue processing attempt started', {
-            attempt: attempts,
-            maxAttempts,
-            remainingOperations: queuedOperations.length,
-            dbId,
-            operation: 'processQueue'
-        });
-        for (let i = queuedOperations.length - 1; i >= 0; i--) {
-            const operation = queuedOperations[i];
-            if (!operation.attribute || !operation.collectionId) {
-                MessageFormatter.warning("Invalid operation, removing from queue");
-                queuedOperations.splice(i, 1);
-                continue;
-            }
-            const attributeKey = operation.attribute.key;
-            const collectionId = operation.collectionId;
-            // Skip if this specific attribute was already processed (per database)
-            if (isAttributeProcessed(dbId, collectionId, attributeKey)) {
-                MessageFormatter.debug(`Attribute '${attributeKey}' already processed, removing from queue`);
-                logger.debug('Removing already processed attribute from queue', {
-                    attributeKey,
-                    collectionId,
-                    queueIndex: i,
-                    operation: 'processQueue'
-                });
-                queuedOperations.splice(i, 1);
-                continue;
-            }
-            let targetCollection;
-            // Resolve the target collection (where the attribute will be created)
-            try {
-                targetCollection = await tryAwaitWithRetry(async () => {
-                    if ('getMetadata' in db && typeof db.getMetadata === 'function') {
-                        // DatabaseAdapter
-                        return (await db.getTable({ databaseId: dbId, tableId: collectionId })).data;
-                    }
-                    else {
-                        // Legacy Databases
-                        return await db.getCollection(dbId, collectionId);
-                    }
-                });
-            }
-            catch (e) {
-                const errorMessage = e instanceof Error ? e.message : String(e);
-                MessageFormatter.error(`Target collection ${collectionId} not found, removing from queue`);
-                logger.error('Target collection not found during queue processing', {
-                    collectionId,
-                    attributeKey,
-                    error: errorMessage,
-                    operation: 'processQueue'
-                });
-                queuedOperations.splice(i, 1);
-                continue;
-            }
-            // For relationship attributes, ensure the related collection exists
-            let canProcess = true;
-            if (operation.attribute.type === "relationship") {
-                const relatedCollection = operation.attribute.relatedCollection;
-                if (relatedCollection) {
-                    // Try to resolve related collection by ID first, then by name
-                    let relatedFound = false;
-                    try {
-                        await tryAwaitWithRetry(async () => {
-                            if ('getMetadata' in db && typeof db.getMetadata === 'function') {
-                                // DatabaseAdapter
-                                return (await db.getTable({ databaseId: dbId, tableId: relatedCollection })).data;
-                            }
-                            else {
-                                // Legacy Databases
-                                return await db.getCollection(dbId, relatedCollection);
-                            }
-                        });
-                        relatedFound = true;
-                        nameToIdMapping.set(relatedCollection, relatedCollection); // Cache the ID mapping
-                    }
-                    catch (_) {
-                        // Try by name lookup
-                        const cachedId = nameToIdMapping.get(relatedCollection);
-                        if (cachedId) {
-                            try {
-                                await tryAwaitWithRetry(async () => {
-                                    if ('getMetadata' in db && typeof db.getMetadata === 'function') {
-                                        // DatabaseAdapter
-                                        return (await db.getTable({ databaseId: dbId, tableId: cachedId })).data;
-                                    }
-                                    else {
-                                        // Legacy Databases
-                                        return await db.getCollection(dbId, cachedId);
-                                    }
-                                });
-                                relatedFound = true;
-                            }
-                            catch (_) {
-                                nameToIdMapping.delete(relatedCollection); // Remove stale cache
-                            }
-                        }
-                        if (!relatedFound) {
-                            // Final attempt: search by name
-                            try {
-                                const collections = 'getMetadata' in db && typeof db.getMetadata === 'function'
-                                    ? await db.listTables({ databaseId: dbId, queries: [Query.equal("name", relatedCollection)] })
-                                    : await db.listCollections(dbId, [Query.equal("name", relatedCollection)]);
-                                if (collections.total && collections.total > 0) {
-                                    const firstCollection = 'getMetadata' in db && typeof db.getMetadata === 'function'
-                                        ? collections.tables?.[0]
-                                        : collections.collections?.[0];
-                                    nameToIdMapping.set(relatedCollection, firstCollection.$id);
-                                    relatedFound = true;
-                                }
-                            }
-                            catch (_) {
-                                // Related collection truly doesn't exist yet
-                            }
-                        }
-                    }
-                    if (!relatedFound) {
-                        MessageFormatter.warning(`Related collection '${relatedCollection}' not ready for attribute '${attributeKey}', keeping in queue`);
-                        canProcess = false;
-                    }
-                }
-            }
-            if (canProcess && targetCollection) {
-                MessageFormatter.progress(`Processing queued ${operation.attribute.type} attribute: '${attributeKey}' for collection: '${targetCollection.name}'`);
-                const success = await createOrUpdateAttributeWithStatusCheck(db, dbId, targetCollection, operation.attribute);
-                if (success) {
-                    MessageFormatter.success(`Successfully processed queued attribute: '${attributeKey}'`);
-                    logger.info('Queued attribute processed successfully', {
-                        attributeKey,
-                        collectionId,
-                        targetCollectionName: targetCollection.name,
-                        operation: 'processQueue'
-                    });
-                    markAttributeProcessed(dbId, collectionId, attributeKey);
-                    queuedOperations.splice(i, 1);
-                    progress = true;
-                }
-                else {
-                    MessageFormatter.error(`Failed to process queued attribute: '${attributeKey}', removing from queue`);
-                    logger.error('Failed to process queued attribute', {
-                        attributeKey,
-                        collectionId,
-                        targetCollectionName: targetCollection.name,
-                        operation: 'processQueue'
-                    });
-                    queuedOperations.splice(i, 1);
-                }
-            }
-        }
-        if (queuedOperations.length === 0) {
-            break;
-        }
-        MessageFormatter.info(`Remaining operations after attempt ${attempts}: ${queuedOperations.length}`);
-    }
-    if (queuedOperations.length > 0) {
-        MessageFormatter.warning(`${queuedOperations.length} operations remain unresolved after ${maxAttempts} attempts:`);
-        queuedOperations.forEach((op, index) => {
-            MessageFormatter.warning(`  ${index + 1}. ${op.attribute?.type} attribute '${op.attribute?.key}' for collection ${op.collectionId}`);
-        });
-        MessageFormatter.warning("These may have unmet dependencies or require manual intervention");
-    }
-    else {
-        MessageFormatter.success("All queued operations processed successfully");
-    }
-    MessageFormatter.section(`Surgical queue processing complete for ${dbId}`);
-};

package/dist/shared/operationsTable.d.ts

@@ -1,26 +0,0 @@
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
-import { type OperationRecord } from "./operationsTableSchema.js";
-/**
- * Creates the operations tracking table in the specified database
- * Table is created with underscore prefix to indicate it's a system table
- */
-export declare function createOperationsTable(db: DatabaseAdapter, databaseId: string): Promise<void>;
-/**
- * Finds an existing operation or creates a new one
- * Useful for resuming interrupted operations
- */
-export declare function findOrCreateOperation(db: DatabaseAdapter, databaseId: string, operationType: string, params?: Partial<OperationRecord>): Promise<OperationRecord>;
-/**
- * Updates an existing operation record
- */
-export declare function updateOperation(db: DatabaseAdapter, databaseId: string, operationId: string, updates: Partial<OperationRecord>): Promise<OperationRecord>;
-/**
- * Gets a single operation by ID
- */
-export declare function getOperation(db: DatabaseAdapter, databaseId: string, operationId: string): Promise<OperationRecord | null>;
-/**
- * Cleans up old completed operations
- * @param olderThan - Optional date, defaults to operations older than 7 days
- * @returns Number of operations deleted
- */
-export declare function cleanupOperations(db: DatabaseAdapter, databaseId: string, olderThan?: Date): Promise<number>;