@njdamstra/appwrite-utils-cli 1.8.9

package/dist/shared/migrationHelpers.d.ts

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,145 @@
+import { ID, Query } from "node-appwrite";
+import { BatchSchema, OperationSchema } from "../storage/schemas.js";
+import { AttributeMappingsSchema } from "@njdamstra/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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,12 @@
+/**
+ * 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

@@ -0,0 +1,40 @@
+import { type Databases, type Models } from "node-appwrite";
+import type { Attribute } from "@njdamstra/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

@@ -0,0 +1,311 @@
+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

@@ -0,0 +1,26 @@
+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>;