appwrite-utils-cli 1.9.7 → 1.11.0

package/dist/storage/schemas.js

@@ -1,175 +0,0 @@
-import { z } from "zod";
-import { attributeSchema, parseAttribute, CollectionCreateSchema, } from "appwrite-utils";
-export const BackupSchema = z.object({
-    $id: z.string(),
-    $createdAt: z.string(),
-    $updatedAt: z.string(),
-    database: z.string(),
-    collections: z.array(z.string()),
-    documents: z
-        .array(z.object({
-        collectionId: z.string(),
-        data: z.string(),
-    }))
-        .default([]),
-});
-export const BackupCreateSchema = BackupSchema.omit({
-    $id: true,
-    $createdAt: true,
-    $updatedAt: true,
-});
-export const BatchSchema = z.object({
-    $id: z.string(),
-    $createdAt: z.string(),
-    $updatedAt: z.string(),
-    data: z.string().describe("The serialized data for this batch"),
-    processed: z
-        .boolean()
-        .default(false)
-        .describe("Whether the batch has been processed"),
-});
-export const BatchCreateSchema = BatchSchema.omit({
-    $id: true,
-    $createdAt: true,
-    $updatedAt: true,
-});
-export const OperationSchema = z.object({
-    $id: z.string(),
-    $createdAt: z.string(),
-    $updatedAt: z.string(),
-    operationType: z.string(),
-    collectionId: z.string(),
-    data: z.any(),
-    batches: z.array(z.string()).default([]).optional(),
-    progress: z.number(),
-    total: z.number(),
-    error: z.string(),
-    status: z
-        .enum([
-        "pending",
-        "ready",
-        "in_progress",
-        "completed",
-        "error",
-        "cancelled",
-    ])
-        .default("pending"),
-});
-export const OperationCreateSchema = OperationSchema.omit({
-    $id: true,
-    $createdAt: true,
-    $updatedAt: true,
-});
-export const getMigrationCollectionSchemas = () => {
-    const currentOperationsAttributes = [
-        parseAttribute({
-            key: "operationType",
-            type: "string",
-            error: "Invalid Operation Type",
-            size: 50,
-            required: true,
-            array: false,
-            xdefault: null,
-        }),
-        attributeSchema.parse({
-            key: "collectionId",
-            type: "string",
-            error: "Invalid Collection Id",
-            size: 50,
-            array: false,
-            xdefault: null,
-        }),
-        attributeSchema.parse({
-            key: "batches",
-            type: "string",
-            error: "Invalid Batches",
-            size: 1073741824,
-            array: true,
-        }),
-        attributeSchema.parse({
-            key: "data",
-            type: "string",
-            error: "Invalid Data",
-            size: 1073741824,
-        }),
-        attributeSchema.parse({
-            key: "progress",
-            type: "integer",
-            error: "Invalid Progress",
-            required: true,
-            array: false,
-        }),
-        attributeSchema.parse({
-            key: "total",
-            type: "integer",
-            error: "Invalid Total",
-            required: true,
-            array: false,
-        }),
-        attributeSchema.parse({
-            key: "error",
-            type: "string",
-            error: "Operation Error",
-            required: false,
-            array: false,
-        }),
-        attributeSchema.parse({
-            key: "status",
-            type: "enum",
-            elements: [
-                "pending",
-                "ready",
-                "in_progress",
-                "completed",
-                "error",
-                "cancelled",
-            ],
-            error: "Invalid Status",
-            array: false,
-            xdefault: "pending",
-        }),
-    ];
-    const currentOperationsConfig = CollectionCreateSchema.parse({
-        name: "CurrentOperations",
-        enabled: true,
-        documentSecurity: false,
-        attributes: [],
-        indexes: [],
-    });
-    const batchesAttributes = [
-        attributeSchema.parse({
-            key: "data",
-            type: "string",
-            size: 1073741824,
-            error: "Invalid Data",
-            required: true,
-            array: false,
-        }),
-        attributeSchema.parse({
-            key: "processed",
-            type: "boolean",
-            error: "Invalid Processed",
-            required: true,
-            array: false,
-            xdefault: false,
-        }),
-    ];
-    const batchesConfig = CollectionCreateSchema.parse({
-        name: "Batches",
-        enabled: true,
-        documentSecurity: false,
-        attributes: [],
-        indexes: [],
-    });
-    const toReturn = {
-        CurrentOperations: {
-            collection: currentOperationsConfig,
-            attributes: currentOperationsAttributes,
-        },
-        Batches: {
-            collection: batchesConfig,
-            attributes: batchesAttributes,
-        },
-    };
-    return toReturn;
-};

package/dist/tables/indexManager.d.ts

@@ -1,65 +0,0 @@
-import type { Index } from "appwrite-utils";
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
-import type { Models } from "node-appwrite";
-export interface IndexOperation {
-    type: 'create' | 'update' | 'skip' | 'delete';
-    index: Index;
-    existingIndex?: Models.Index;
-    reason?: string;
-}
-export interface IndexOperationPlan {
-    toCreate: IndexOperation[];
-    toUpdate: IndexOperation[];
-    toSkip: IndexOperation[];
-    toDelete: IndexOperation[];
-}
-export interface IndexExecutionResult {
-    created: string[];
-    updated: string[];
-    skipped: string[];
-    deleted: string[];
-    errors: Array<{
-        key: string;
-        error: string;
-    }>;
-    summary: {
-        total: number;
-        created: number;
-        updated: number;
-        skipped: number;
-        deleted: number;
-        errors: number;
-    };
-}
-/**
- * Plan index operations by comparing desired indexes with existing ones
- * Uses the existing isIndexEqualToIndex function for consistent comparison
- */
-export declare function planIndexOperations(desiredIndexes: Index[], existingIndexes: Models.Index[]): IndexOperationPlan;
-/**
- * Plan index deletions for indexes that exist but aren't in the desired configuration
- */
-export declare function planIndexDeletions(desiredIndexKeys: Set<string>, existingIndexes: Models.Index[]): IndexOperation[];
-/**
- * Execute index operations with proper error handling and status monitoring
- */
-export declare function executeIndexOperations(adapter: DatabaseAdapter, databaseId: string, tableId: string, plan: IndexOperationPlan): Promise<IndexExecutionResult>;
-/**
- * Execute index deletions with proper error handling
- */
-export declare function executeIndexDeletions(adapter: DatabaseAdapter, databaseId: string, tableId: string, deletions: IndexOperation[]): Promise<{
-    deleted: string[];
-    errors: Array<{
-        key: string;
-        error: string;
-    }>;
-}>;
-/**
- * Main function to create/update indexes via adapter
- * This replaces the messy inline code in methods.ts
- */
-export declare function createOrUpdateIndexesViaAdapter(adapter: DatabaseAdapter, databaseId: string, tableId: string, desiredIndexes: Index[], configIndexes?: Index[]): Promise<void>;
-/**
- * Handle index deletions for obsolete indexes
- */
-export declare function deleteObsoleteIndexesViaAdapter(adapter: DatabaseAdapter, databaseId: string, tableId: string, desiredIndexKeys: Set<string>): Promise<void>;

package/dist/tables/indexManager.js

@@ -1,294 +0,0 @@
-import { isIndexEqualToIndex } from "../collections/tableOperations.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-import { delay, tryAwaitWithRetry } from "../utils/helperFunctions.js";
-/**
- * Plan index operations by comparing desired indexes with existing ones
- * Uses the existing isIndexEqualToIndex function for consistent comparison
- */
-export function planIndexOperations(desiredIndexes, existingIndexes) {
-    const plan = {
-        toCreate: [],
-        toUpdate: [],
-        toSkip: [],
-        toDelete: []
-    };
-    for (const desiredIndex of desiredIndexes) {
-        const existingIndex = existingIndexes.find(idx => idx.key === desiredIndex.key);
-        if (!existingIndex) {
-            // Index doesn't exist - create it
-            plan.toCreate.push({
-                type: 'create',
-                index: desiredIndex,
-                reason: 'New index'
-            });
-        }
-        else if (isIndexEqualToIndex(existingIndex, desiredIndex)) {
-            // Index exists and is identical - skip it
-            plan.toSkip.push({
-                type: 'skip',
-                index: desiredIndex,
-                existingIndex,
-                reason: 'Index unchanged'
-            });
-        }
-        else {
-            // Index exists but is different - update it
-            plan.toUpdate.push({
-                type: 'update',
-                index: desiredIndex,
-                existingIndex,
-                reason: 'Index configuration changed'
-            });
-        }
-    }
-    return plan;
-}
-/**
- * Plan index deletions for indexes that exist but aren't in the desired configuration
- */
-export function planIndexDeletions(desiredIndexKeys, existingIndexes) {
-    const deletions = [];
-    for (const existingIndex of existingIndexes) {
-        if (!desiredIndexKeys.has(existingIndex.key)) {
-            deletions.push({
-                type: 'delete',
-                index: existingIndex, // Convert Models.Index to Index for compatibility
-                reason: 'Obsolete index'
-            });
-        }
-    }
-    return deletions;
-}
-/**
- * Execute index operations with proper error handling and status monitoring
- */
-export async function executeIndexOperations(adapter, databaseId, tableId, plan) {
-    const result = {
-        created: [],
-        updated: [],
-        skipped: [],
-        deleted: [],
-        errors: [],
-        summary: {
-            total: 0,
-            created: 0,
-            updated: 0,
-            skipped: 0,
-            deleted: 0,
-            errors: 0
-        }
-    };
-    // Execute creates
-    for (const operation of plan.toCreate) {
-        try {
-            await adapter.createIndex({
-                databaseId,
-                tableId,
-                key: operation.index.key,
-                type: operation.index.type,
-                attributes: operation.index.attributes,
-                orders: operation.index.orders || []
-            });
-            result.created.push(operation.index.key);
-            MessageFormatter.success(`Created index ${operation.index.key}`, { prefix: 'Indexes' });
-            // Wait for index to become available
-            await waitForIndexAvailable(adapter, databaseId, tableId, operation.index.key);
-            await delay(150); // Brief delay between operations
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            result.errors.push({ key: operation.index.key, error: errorMessage });
-            MessageFormatter.error(`Failed to create index ${operation.index.key}`, error instanceof Error ? error : new Error(String(error)), { prefix: 'Indexes' });
-        }
-    }
-    // Execute updates (delete + recreate)
-    for (const operation of plan.toUpdate) {
-        try {
-            // Delete existing index first
-            await adapter.deleteIndex({
-                databaseId,
-                tableId,
-                key: operation.index.key
-            });
-            await delay(100); // Brief delay for deletion to settle
-            // Create new index
-            await adapter.createIndex({
-                databaseId,
-                tableId,
-                key: operation.index.key,
-                type: operation.index.type,
-                attributes: operation.index.attributes,
-                orders: operation.index.orders || operation.existingIndex?.orders || []
-            });
-            result.updated.push(operation.index.key);
-            MessageFormatter.success(`Updated index ${operation.index.key}`, { prefix: 'Indexes' });
-            // Wait for index to become available
-            await waitForIndexAvailable(adapter, databaseId, tableId, operation.index.key);
-            await delay(150); // Brief delay between operations
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            result.errors.push({ key: operation.index.key, error: errorMessage });
-            MessageFormatter.error(`Failed to update index ${operation.index.key}`, error instanceof Error ? error : new Error(String(error)), { prefix: 'Indexes' });
-        }
-    }
-    // Execute skips
-    for (const operation of plan.toSkip) {
-        result.skipped.push(operation.index.key);
-        MessageFormatter.info(`Index ${operation.index.key} unchanged`, { prefix: 'Indexes' });
-    }
-    // Calculate summary
-    result.summary.total = result.created.length + result.updated.length + result.skipped.length + result.deleted.length;
-    result.summary.created = result.created.length;
-    result.summary.updated = result.updated.length;
-    result.summary.skipped = result.skipped.length;
-    result.summary.deleted = result.deleted.length;
-    result.summary.errors = result.errors.length;
-    return result;
-}
-/**
- * Execute index deletions with proper error handling
- */
-export async function executeIndexDeletions(adapter, databaseId, tableId, deletions) {
-    const result = {
-        deleted: [],
-        errors: []
-    };
-    for (const operation of deletions) {
-        try {
-            await adapter.deleteIndex({
-                databaseId,
-                tableId,
-                key: operation.index.key
-            });
-            result.deleted.push(operation.index.key);
-            MessageFormatter.info(`Deleted obsolete index ${operation.index.key}`, { prefix: 'Indexes' });
-            // Wait briefly for deletion to settle
-            await delay(500);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            result.errors.push({ key: operation.index.key, error: errorMessage });
-            MessageFormatter.error(`Failed to delete index ${operation.index.key}`, error instanceof Error ? error : new Error(String(error)), { prefix: 'Indexes' });
-        }
-    }
-    return result;
-}
-/**
- * Wait for an index to become available with timeout and retry logic
- * This is an adapter-aware version of the logic from collections/indexes.ts
- */
-async function waitForIndexAvailable(adapter, databaseId, tableId, indexKey, maxWaitTime = 60000, // 1 minute
-checkInterval = 2000 // 2 seconds
-) {
-    const startTime = Date.now();
-    while (Date.now() - startTime < maxWaitTime) {
-        try {
-            const indexList = await adapter.listIndexes({ databaseId, tableId });
-            const indexes = indexList.data || indexList.indexes || [];
-            const index = indexes.find((idx) => idx.key === indexKey);
-            if (!index) {
-                MessageFormatter.error(`Index '${indexKey}' not found after creation`, undefined, { prefix: 'Indexes' });
-                return false;
-            }
-            switch (index.status) {
-                case 'available':
-                    return true;
-                case 'failed':
-                    MessageFormatter.error(`Index '${indexKey}' failed: ${index.error || 'unknown error'}`, undefined, { prefix: 'Indexes' });
-                    return false;
-                case 'stuck':
-                    MessageFormatter.warning(`Index '${indexKey}' is stuck`, { prefix: 'Indexes' });
-                    return false;
-                case 'processing':
-                case 'deleting':
-                    // Continue waiting
-                    break;
-                default:
-                    MessageFormatter.warning(`Unknown status '${index.status}' for index '${indexKey}'`, { prefix: 'Indexes' });
-                    break;
-            }
-        }
-        catch (error) {
-            MessageFormatter.error(`Error checking index '${indexKey}' status: ${error}`, undefined, { prefix: 'Indexes' });
-        }
-        await delay(checkInterval);
-    }
-    MessageFormatter.warning(`Timeout waiting for index '${indexKey}' to become available (${maxWaitTime}ms)`, { prefix: 'Indexes' });
-    return false;
-}
-/**
- * Main function to create/update indexes via adapter
- * This replaces the messy inline code in methods.ts
- */
-export async function createOrUpdateIndexesViaAdapter(adapter, databaseId, tableId, desiredIndexes, configIndexes) {
-    if (!desiredIndexes || desiredIndexes.length === 0) {
-        MessageFormatter.info('No indexes to process', { prefix: 'Indexes' });
-        return;
-    }
-    MessageFormatter.info(`Processing ${desiredIndexes.length} indexes for table ${tableId}`, { prefix: 'Indexes' });
-    try {
-        // Get existing indexes
-        const existingIdxRes = await adapter.listIndexes({ databaseId, tableId });
-        const existingIndexes = existingIdxRes.data || existingIdxRes.indexes || [];
-        // Plan operations
-        const plan = planIndexOperations(desiredIndexes, existingIndexes);
-        // Show plan with icons (consistent with attribute handling)
-        const planParts = [];
-        if (plan.toCreate.length)
-            planParts.push(`➕  ${plan.toCreate.length} (${plan.toCreate.map(op => op.index.key).join(', ')})`);
-        if (plan.toUpdate.length)
-            planParts.push(`🔧  ${plan.toUpdate.length} (${plan.toUpdate.map(op => op.index.key).join(', ')})`);
-        if (plan.toSkip.length)
-            planParts.push(`⏭️  ${plan.toSkip.length}`);
-        MessageFormatter.info(`Plan → ${planParts.join('  |  ') || 'no changes'}`, { prefix: 'Indexes' });
-        // Execute operations
-        const result = await executeIndexOperations(adapter, databaseId, tableId, plan);
-        // Show summary
-        MessageFormatter.info(`Summary → ➕  ${result.summary.created}  |  🔧  ${result.summary.updated}  |  ⏭️  ${result.summary.skipped}`, { prefix: 'Indexes' });
-        // Handle errors if any
-        if (result.errors.length > 0) {
-            MessageFormatter.error(`${result.errors.length} index operations failed:`, undefined, { prefix: 'Indexes' });
-            for (const error of result.errors) {
-                MessageFormatter.error(`  ${error.key}: ${error.error}`, undefined, { prefix: 'Indexes' });
-            }
-        }
-    }
-    catch (error) {
-        MessageFormatter.error('Failed to process indexes', error instanceof Error ? error : new Error(String(error)), { prefix: 'Indexes' });
-        throw error;
-    }
-}
-/**
- * Handle index deletions for obsolete indexes
- */
-export async function deleteObsoleteIndexesViaAdapter(adapter, databaseId, tableId, desiredIndexKeys) {
-    try {
-        // Get existing indexes
-        const existingIdxRes = await adapter.listIndexes({ databaseId, tableId });
-        const existingIndexes = existingIdxRes.data || existingIdxRes.indexes || [];
-        // Plan deletions
-        const deletions = planIndexDeletions(desiredIndexKeys, existingIndexes);
-        if (deletions.length === 0) {
-            MessageFormatter.info('Plan → 🗑️  0 indexes', { prefix: 'Indexes' });
-            return;
-        }
-        // Show deletion plan
-        MessageFormatter.info(`Plan → 🗑️  ${deletions.length} (${deletions.map(op => op.index.key).join(', ')})`, { prefix: 'Indexes' });
-        // Execute deletions
-        const result = await executeIndexDeletions(adapter, databaseId, tableId, deletions);
-        // Show results
-        if (result.deleted.length > 0) {
-            MessageFormatter.success(`Deleted ${result.deleted.length} indexes: ${result.deleted.join(', ')}`, { prefix: 'Indexes' });
-        }
-        if (result.errors.length > 0) {
-            MessageFormatter.error(`${result.errors.length} index deletions failed:`, undefined, { prefix: 'Indexes' });
-            for (const error of result.errors) {
-                MessageFormatter.error(`  ${error.key}: ${error.error}`, undefined, { prefix: 'Indexes' });
-            }
-        }
-    }
-    catch (error) {
-        MessageFormatter.warning(`Could not evaluate index deletions: ${error?.message || error}`, { prefix: 'Indexes' });
-    }
-}

package/dist/types.d.ts

@@ -1,4 +0,0 @@
-export type { ValidationRules } from "./utils/validationRules.js";
-export { type AuthUserCreate, AuthUserCreateSchema, type AuthUser, AuthUserSchema, } from "./schemas/authUser.js";
-export { validationRules } from "./utils/validationRules.js";
-export { afterImportActions } from "./migrations/afterImportActions.js";

package/dist/types.js

@@ -1,3 +0,0 @@
-export { AuthUserCreateSchema, AuthUserSchema, } from "./schemas/authUser.js";
-export { validationRules } from "./utils/validationRules.js";
-export { afterImportActions } from "./migrations/afterImportActions.js";

package/dist/users/methods.d.ts

@@ -1,16 +0,0 @@
-import type { AppwriteConfig } from "appwrite-utils";
-import { Databases, type Models } from "node-appwrite";
-import { type AuthUserCreate } from "../schemas/authUser.js";
-export declare class UsersController {
-    private config;
-    private users;
-    static userFields: string[];
-    constructor(config: AppwriteConfig, db: Databases);
-    wipeUsers(): Promise<void>;
-    getAllUsers(): Promise<Models.User<Models.Preferences>[]>;
-    createUsersAndReturn(items: AuthUserCreate[]): Promise<any[]>;
-    createUserAndReturn(item: AuthUserCreate): Promise<any>;
-    createAndCheckForUserAndReturn(item: AuthUserCreate): Promise<Models.User<Models.Preferences> | undefined>;
-    getUserIdByEmailOrPhone(email?: string, phone?: string): Promise<string | undefined>;
-    transferUsersBetweenDbsLocalToRemote: (endpoint: string, projectId: string, apiKey: string) => Promise<void>;
-}