@njdamstra/appwrite-utils-cli 1.8.9 → 1.10.0

package/dist/collections/tableOperations.js

@@ -1,4 +1,4 @@
-import { mapToCreateAttributeParams, mapToUpdateAttributeParams } from "../shared/attributeMapper.js";
+import { mapToCreateAttributeParams, mapToUpdateAttributeParams } from "@njdamstra/appwrite-utils-helpers";
 import { Decimal } from "decimal.js";
 const EXTREME_BOUND = new Decimal('1e12');
 // Property configuration for different column types
@@ -90,11 +90,13 @@ export function normalizeAttributeToComparable(attr) {
     return base;
 }
 export function normalizeColumnToComparable(col) {
-    // Detect enum surfaced as string+elements from server and normalize to enum for comparison
+    // Detect enum surfaced as string+elements or string+format:enum from server and normalize to enum for comparison
     let t = String((col?.type ?? col?.columnType ?? '')).toLowerCase();
     const hasElements = Array.isArray(col?.elements) && col.elements.length > 0;
-    if (t === 'string' && hasElements)
+    const hasEnumFormat = (col?.format === 'enum');
+    if (t === 'string' && (hasElements || hasEnumFormat)) {
         t = 'enum';
+    }
     const base = {
         key: col?.key,
         type: t,
@@ -185,18 +187,27 @@ export function isIndexEqualToIndex(a, b) {
     if (String(a.type).toLowerCase() !== String(b.type).toLowerCase())
         return false;
     // Compare attributes as sets (order-insensitive)
-    const attrsA = Array.isArray(a.attributes) ? [...a.attributes].sort() : [];
-    const attrsB = Array.isArray(b.attributes) ? [...b.attributes].sort() : [];
+    // Support TablesDB which returns 'columns' instead of 'attributes'
+    const attrsAraw = Array.isArray(a.attributes)
+        ? a.attributes
+        : (Array.isArray(a.columns) ? a.columns : []);
+    const attrsA = [...attrsAraw].sort();
+    const attrsB = Array.isArray(b.attributes)
+        ? [...b.attributes].sort()
+        : (Array.isArray(b.columns) ? [...b.columns].sort() : []);
     if (attrsA.length !== attrsB.length)
         return false;
     for (let i = 0; i < attrsA.length; i++)
         if (attrsA[i] !== attrsB[i])
             return false;
-    // Orders are only considered if BOTH have orders defined
-    const hasOrdersA = Array.isArray(a.orders) && a.orders.length > 0;
-    const hasOrdersB = Array.isArray(b.orders) && b.orders.length > 0;
-    if (hasOrdersA && hasOrdersB) {
-        const ordersA = [...a.orders].sort();
+    // Orders are only considered if CONFIG (b) has orders defined
+    // This prevents false positives when Appwrite returns orders but user didn't specify them
+    const hasConfigOrders = Array.isArray(b.orders) && b.orders.length > 0;
+    if (hasConfigOrders) {
+        // Some APIs may expose 'directions' instead of 'orders'
+        const ordersA = Array.isArray(a.orders)
+            ? [...a.orders].sort()
+            : (Array.isArray(a.directions) ? [...a.directions].sort() : []);
         const ordersB = [...b.orders].sort();
         if (ordersA.length !== ordersB.length)
             return false;
@@ -204,7 +215,6 @@ export function isIndexEqualToIndex(a, b) {
             if (ordersA[i] !== ordersB[i])
                 return false;
     }
-    // If only one side has orders, treat as equal (orders unspecified by user)
     return true;
 }
 /**
@@ -213,6 +223,7 @@ export function isIndexEqualToIndex(a, b) {
 function compareColumnProperties(oldColumn, newAttribute, columnType) {
     const changes = [];
     const t = String(columnType || newAttribute.type || '').toLowerCase();
+    const key = newAttribute?.key || 'unknown';
     const mutableProps = MUTABLE_PROPERTIES[t] || [];
     const immutableProps = IMMUTABLE_PROPERTIES[t] || [];
     const getNewVal = (prop) => {
@@ -233,8 +244,9 @@ function compareColumnProperties(oldColumn, newAttribute, columnType) {
         let newValue = getNewVal(prop);
         // Special-case: enum elements empty/missing should not trigger updates
         if (t === 'enum' && prop === 'elements') {
-            if (!Array.isArray(newValue) || newValue.length === 0)
+            if (!Array.isArray(newValue) || newValue.length === 0) {
                 newValue = oldValue;
+            }
         }
         if (Array.isArray(oldValue) && Array.isArray(newValue)) {
             if (oldValue.length !== newValue.length || oldValue.some((v, i) => v !== newValue[i])) {
@@ -260,7 +272,8 @@ function compareColumnProperties(oldColumn, newAttribute, columnType) {
     // Type change requires recreate (normalize string+elements to enum on old side)
     const oldTypeRaw = String(oldColumn?.type || oldColumn?.columnType || '').toLowerCase();
     const oldHasElements = Array.isArray(oldColumn?.elements) && oldColumn.elements.length > 0;
-    const oldType = oldTypeRaw === 'string' && oldHasElements ? 'enum' : oldTypeRaw;
+    const oldHasEnumFormat = (oldColumn?.format === 'enum');
+    const oldType = oldTypeRaw === 'string' && (oldHasElements || oldHasEnumFormat) ? 'enum' : oldTypeRaw;
     if (oldType && t && oldType !== t && TYPE_CHANGE_REQUIRES_RECREATE.includes(oldType)) {
         changes.push({ property: 'type', oldValue: oldType, newValue: t, requiresRecreate: true });
     }
@@ -299,29 +312,48 @@ function analyzeColumnChanges(oldColumn, newAttribute) {
 /**
  * Enhanced version of columns diff with detailed change analysis
  * Order: desired first, then existing (matches internal usage here)
+ * Handles case-insensitive key matches as renames (recreates)
  */
 export function diffColumnsDetailed(desiredAttributes, existingColumns) {
+    // Exact key lookup (case-sensitive)
     const byKey = new Map((existingColumns || []).map((col) => [col?.key, col]));
+    // Case-insensitive key lookup for detecting renames
+    const byKeyLower = new Map((existingColumns || []).map((col) => [col?.key?.toLowerCase(), col]));
     const toCreate = [];
     const toUpdate = [];
     const toRecreate = [];
     const unchanged = [];
+    const handledExistingKeys = new Set(); // Track which existing columns we've handled
     for (const attr of desiredAttributes || []) {
         const key = attr?.key;
-        const existing = key ? byKey.get(key) : undefined;
-        if (!existing) {
-            toCreate.push(attr);
+        if (!key)
+            continue;
+        // First try exact match
+        const exactMatch = byKey.get(key);
+        if (exactMatch) {
+            handledExistingKeys.add(key);
+            const analysis = analyzeColumnChanges(exactMatch, attr);
+            if (!analysis.hasChanges)
+                unchanged.push(analysis.columnKey);
+            else if (analysis.requiresRecreate)
+                toRecreate.push({ oldAttribute: exactMatch, newAttribute: attr });
+            else
+                toUpdate.push({ attribute: attr, changes: analysis.changes });
             continue;
         }
-        const analysis = analyzeColumnChanges(existing, attr);
-        if (!analysis.hasChanges)
-            unchanged.push(analysis.columnKey);
-        else if (analysis.requiresRecreate)
-            toRecreate.push({ oldAttribute: existing, newAttribute: attr });
-        else
-            toUpdate.push({ attribute: attr, changes: analysis.changes });
+        // Check for case-insensitive match (rename scenario like oAuthAccounts -> oauthAccounts)
+        const caseInsensitiveMatch = byKeyLower.get(key.toLowerCase());
+        if (caseInsensitiveMatch && caseInsensitiveMatch.key !== key) {
+            // This is a rename - treat as recreate (delete old, create new)
+            handledExistingKeys.add(caseInsensitiveMatch.key);
+            toRecreate.push({ oldAttribute: caseInsensitiveMatch, newAttribute: attr });
+            continue;
+        }
+        // No match - it's a new attribute
+        toCreate.push(attr);
     }
     // Note: we keep toDelete empty for now (conservative behavior)
+    // Deletions are handled separately in methods.ts
     return { toCreate, toUpdate, toRecreate, toDelete: [], unchanged };
 }
 /**

package/dist/collections/transferOperations.d.ts

@@ -1,5 +1,5 @@
 import { Databases } from "node-appwrite";
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import type { DatabaseAdapter } from "@njdamstra/appwrite-utils-helpers";
 /**
  * Transfers all documents from one collection to another in a different database
  * within the same Appwrite Project

package/dist/collections/transferOperations.js

@@ -1,9 +1,8 @@
 import { Client, Databases, ID, Query, } from "node-appwrite";
-import { tryAwaitWithRetry, delay, calculateExponentialBackoff } from "../utils/helperFunctions.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
+import { tryAwaitWithRetry, delay, calculateExponentialBackoff, MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
 import { chunk } from "es-toolkit";
-import { isLegacyDatabases } from "../utils/typeGuards.js";
-import { getAdapter } from "../utils/getClientFromConfig.js";
+import { isLegacyDatabases } from "@njdamstra/appwrite-utils-helpers";
+import { getAdapter } from "@njdamstra/appwrite-utils-helpers";
 /**
  * Transfers all documents from one collection to another in a different database
  * within the same Appwrite Project

package/dist/collections/wipeOperations.d.ts

@@ -1,5 +1,5 @@
 import { Databases } from "node-appwrite";
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import type { DatabaseAdapter } from "@njdamstra/appwrite-utils-helpers";
 export declare const wipeDatabase: (database: Databases, databaseId: string) => Promise<{
     collectionId: string;
     collectionName: string;
@@ -10,7 +10,8 @@ export declare const wipeAllTables: (adapter: DatabaseAdapter, databaseId: strin
     tableName: string;
 }[]>;
 /**
- * Optimized deletion of all rows from a table using direct bulk deletion
- * Uses Query.limit() to delete rows without fetching IDs first
+ * Optimized deletion of all rows from a table.
+ * Uses bulk deletion when possible, but falls back to individual row deletion
+ * for tables with relationship columns (bulk delete not supported for those).
  */
 export declare const wipeTableRows: (adapter: DatabaseAdapter, databaseId: string, tableId: string) => Promise<void>;

package/dist/collections/wipeOperations.js

@@ -1,9 +1,8 @@
 import { Databases, Query, } from "node-appwrite";
-import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
+import { tryAwaitWithRetry } from "@njdamstra/appwrite-utils-helpers";
+import { MessageFormatter, isRetryableError, isCriticalError } from "@njdamstra/appwrite-utils-helpers";
 import { ProgressManager } from "../shared/progressManager.js";
-import { isRetryableError, isCriticalError } from "../shared/errorUtils.js";
-import { delay } from "../utils/helperFunctions.js";
+import { delay } from "@njdamstra/appwrite-utils-helpers";
 import { chunk } from "es-toolkit";
 import pLimit from "p-limit";
 import { fetchAllCollections } from "./methods.js";
@@ -167,52 +166,126 @@ export const wipeAllTables = async (adapter, databaseId) => {
     return deleted;
 };
 /**
- * Optimized deletion of all rows from a table using direct bulk deletion
- * Uses Query.limit() to delete rows without fetching IDs first
+ * Optimized deletion of all rows from a table.
+ * Uses bulk deletion when possible, but falls back to individual row deletion
+ * for tables with relationship columns (bulk delete not supported for those).
  */
 export const wipeTableRows = async (adapter, databaseId, tableId) => {
     try {
-        // Check if bulk deletion is available
-        if (!adapter.bulkDeleteRows) {
-            MessageFormatter.error("Bulk deletion not available for this adapter - wipe operation not supported", new Error("bulkDeleteRows not available"), { prefix: "Wipe" });
-            throw new Error("Bulk deletion required for wipe operations");
-        }
-        const DELETE_BATCH_SIZE = 250; // How many rows to delete per batch
+        // Check if the table has relationship columns — bulk delete is not supported for those
+        const tableInfo = await adapter.getTable({ databaseId, tableId });
+        const columns = tableInfo.data?.columns || [];
+        const hasRelationships = columns.some((col) => col.type === "relationship");
+        const DELETE_BATCH_SIZE = 250;
         let totalDeleted = 0;
         let hasMoreRows = true;
-        MessageFormatter.info("Starting optimized table row deletion...", { prefix: "Wipe" });
-        const progress = ProgressManager.create(`delete-${tableId}`, 1, // Start with 1, will update as we discover more
-        { title: "Deleting table rows" });
-        while (hasMoreRows) {
-            try {
-                // Delete next batch using Query.limit() - no fetching needed!
-                const result = await tryAwaitWithRetry(async () => adapter.bulkDeleteRows({
-                    databaseId,
-                    tableId,
-                    rowIds: [], // Empty array signals we want to use Query.limit instead
-                    batchSize: DELETE_BATCH_SIZE
-                }));
-                const deletedCount = result.total || 0;
-                if (deletedCount === 0) {
+        const progress = ProgressManager.create(`delete-${tableId}`, 1, { title: "Deleting table rows" });
+        if (hasRelationships) {
+            // ── Relationship table: fetch rows then delete individually ──
+            MessageFormatter.info("Table has relationship columns — using individual row deletion (bulk delete not supported)", { prefix: "Wipe" });
+            const FETCH_BATCH_SIZE = 1000;
+            const MAX_CONCURRENT_DELETES = 25;
+            const limit = pLimit(MAX_CONCURRENT_DELETES);
+            // Pipeline: prefetch the first batch, then overlap fetch+delete
+            let pendingRows = [];
+            let totalDiscovered = 0;
+            // Fetch helper — always fetches from the top since we're deleting everything
+            const fetchBatch = async () => {
+                const queries = [Query.limit(FETCH_BATCH_SIZE)];
+                const response = await tryAwaitWithRetry(async () => adapter.listRows({ databaseId, tableId, queries }));
+                return response.rows || response.data || [];
+            };
+            // Kick off the first fetch
+            let nextFetchPromise = fetchBatch();
+            while (hasMoreRows) {
+                // Await the prefetched batch
+                const rows = nextFetchPromise ? await nextFetchPromise : [];
+                nextFetchPromise = null;
+                if (rows.length === 0) {
                     hasMoreRows = false;
                     break;
                 }
-                totalDeleted += deletedCount;
-                progress.setTotal(totalDeleted + 100); // Estimate more rows exist
-                progress.update(totalDeleted);
-                MessageFormatter.progress(`Deleted ${deletedCount} rows (${totalDeleted} total so far)`, { prefix: "Wipe" });
-                // Small delay between batches to be respectful to the API
+                totalDiscovered += rows.length;
+                const isLastBatch = rows.length < FETCH_BATCH_SIZE;
+                if (!isLastBatch) {
+                    progress.setTotal(totalDiscovered + 1000);
+                }
+                else {
+                    progress.setTotal(totalDiscovered);
+                }
+                MessageFormatter.progress(`Fetched ${rows.length} rows (${totalDiscovered} discovered, ${totalDeleted} deleted so far)`, { prefix: "Wipe" });
+                // Start deleting this batch — and prefetch the next one concurrently
+                // (only prefetch if we expect more rows)
+                if (!isLastBatch) {
+                    // Wait a moment before prefetching so the first few deletes free up API capacity
+                    nextFetchPromise = delay(200).then(() => fetchBatch());
+                }
+                // Delete each row with concurrency limit
+                const deletePromises = rows.map((row) => limit(async () => {
+                    try {
+                        await tryAwaitWithRetry(async () => adapter.deleteRow({ databaseId, tableId, id: row.$id }));
+                        totalDeleted++;
+                        progress.update(totalDeleted);
+                    }
+                    catch (error) {
+                        const errorMessage = error.message || String(error);
+                        if (errorMessage.includes("could not be found")) {
+                            totalDeleted++;
+                            progress.update(totalDeleted);
+                        }
+                        else if (isCriticalError(errorMessage)) {
+                            MessageFormatter.error(`Critical error deleting row ${row.$id}: ${errorMessage}`, error, { prefix: "Wipe" });
+                            throw error;
+                        }
+                        else {
+                            MessageFormatter.error(`Failed to delete row ${row.$id}: ${errorMessage}`, error, { prefix: "Wipe" });
+                            totalDeleted++;
+                            progress.update(totalDeleted);
+                        }
+                    }
+                }));
+                await Promise.all(deletePromises);
+                if (isLastBatch) {
+                    hasMoreRows = false;
+                }
                 await delay(10);
             }
-            catch (error) {
-                const errorMessage = error.message || String(error);
-                if (isCriticalError(errorMessage)) {
-                    MessageFormatter.error(`Critical error during bulk deletion: ${errorMessage}`, error, { prefix: "Wipe" });
-                    throw error;
+        }
+        else {
+            // ── No relationships: use fast bulk deletion ──
+            if (!adapter.bulkDeleteRows) {
+                MessageFormatter.error("Bulk deletion not available for this adapter - wipe operation not supported", new Error("bulkDeleteRows not available"), { prefix: "Wipe" });
+                throw new Error("Bulk deletion required for wipe operations");
+            }
+            MessageFormatter.info("Starting optimized table row deletion...", { prefix: "Wipe" });
+            while (hasMoreRows) {
+                try {
+                    const result = await tryAwaitWithRetry(async () => adapter.bulkDeleteRows({
+                        databaseId,
+                        tableId,
+                        rowIds: [],
+                        batchSize: DELETE_BATCH_SIZE
+                    }));
+                    const deletedCount = result.total || 0;
+                    if (deletedCount === 0) {
+                        hasMoreRows = false;
+                        break;
+                    }
+                    totalDeleted += deletedCount;
+                    progress.setTotal(totalDeleted + 100);
+                    progress.update(totalDeleted);
+                    MessageFormatter.progress(`Deleted ${deletedCount} rows (${totalDeleted} total so far)`, { prefix: "Wipe" });
+                    await delay(10);
                 }
-                else {
-                    MessageFormatter.error(`Error during deletion batch: ${errorMessage}`, error, { prefix: "Wipe" });
-                    // Continue trying with next batch
+                catch (error) {
+                    const errorMessage = error.message || String(error);
+                    if (isCriticalError(errorMessage)) {
+                        MessageFormatter.error(`Critical error during bulk deletion: ${errorMessage}`, error, { prefix: "Wipe" });
+                        throw error;
+                    }
+                    else {
+                        MessageFormatter.error(`Error during deletion batch: ${errorMessage}`, error, { prefix: "Wipe" });
+                    }
                 }
             }
         }

package/dist/databases/methods.js

@@ -1,7 +1,7 @@
 import { Databases, Query } from "node-appwrite";
-import { delay, tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import { delay, tryAwaitWithRetry } from "@njdamstra/appwrite-utils-helpers";
 import { fetchAllCollections } from "../collections/methods.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
+import { MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
 export const fetchAllDatabases = async (database) => {
     const databases = await tryAwaitWithRetry(async () => await database.list([Query.limit(25)]));
     const allDatabases = databases.databases;

package/dist/databases/setup.js

@@ -1,8 +1,8 @@
 import { Databases, Query } from "node-appwrite";
-import { tryAwaitWithRetry } from "../utils/index.js";
+import { tryAwaitWithRetry } from "@njdamstra/appwrite-utils-helpers";
 import {} from "@njdamstra/appwrite-utils";
 import { ulid } from "ulidx";
-import { MessageFormatter } from "../shared/messageFormatter.js";
+import { MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
 export const ensureDatabasesExist = async (config, databasesToEnsure) => {
     if (!config.appwriteClient) {
         throw new Error("Appwrite client is not initialized in the config");

package/dist/examples/yamlTerminologyExample.js

@@ -7,8 +7,8 @@
  * 3. Validate terminology consistency
  * 4. Migrate between formats
  */
-import { collectionToYaml, generateYamlTemplate, generateExampleYamls, convertTerminology, normalizeYamlData, usesTableTerminology } from "../utils/yamlConverter.js";
-import { createYamlLoader } from "../utils/yamlLoader.js";
+import { collectionToYaml, generateYamlTemplate, generateExampleYamls, convertTerminology, normalizeYamlData, usesTableTerminology } from "@njdamstra/appwrite-utils-helpers";
+import { createYamlLoader } from "@njdamstra/appwrite-utils-helpers";
 import { YamlImportIntegration } from "../migrations/yaml/YamlImportIntegration.js";
 import { createImportSchemas } from "../migrations/yaml/generateImportSchemas.js";
 import { CollectionCreateSchema } from "@njdamstra/appwrite-utils";

package/dist/functions/deployments.d.ts

@@ -1,4 +1,4 @@
 import { Client, type Models } from "node-appwrite";
 import { type AppwriteFunction } from "@njdamstra/appwrite-utils";
 export declare const deployFunction: (client: Client, functionId: string, codePath: string, activate?: boolean, entrypoint?: string, commands?: string, ignored?: string[]) => Promise<Models.Deployment>;
-export declare const deployLocalFunction: (client: Client, functionName: string, functionConfig: AppwriteFunction, functionPath?: string) => Promise<Models.Deployment>;
+export declare const deployLocalFunction: (client: Client, functionName: string, functionConfig: AppwriteFunction, functionPath?: string, configDirPath?: string) => Promise<Models.Deployment>;

package/dist/functions/deployments.js

@@ -10,8 +10,8 @@ import cliProgress from "cli-progress";
 import { execSync } from "child_process";
 import { createFunction, getFunction, updateFunction, updateFunctionSpecifications, } from "./methods.js";
 import ignore from "ignore";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-import { resolveFunctionDirectory, validateFunctionDirectory } from './pathResolution.js';
+import { MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
+import { resolveFunctionDirectory, validateFunctionDirectory } from '@njdamstra/appwrite-utils-helpers';
 export const deployFunction = async (client, functionId, codePath, activate = true, entrypoint = "index.js", commands = "npm install", ignored = [
     "node_modules",
     ".git",
@@ -98,7 +98,7 @@ export const deployFunction = async (client, functionId, codePath, activate = tr
         throw error;
     }
 };
-export const deployLocalFunction = async (client, functionName, functionConfig, functionPath) => {
+export const deployLocalFunction = async (client, functionName, functionConfig, functionPath, configDirPath) => {
     let functionExists = true;
     let functionThatExists;
     try {
@@ -107,8 +107,8 @@ export const deployLocalFunction = async (client, functionName, functionConfig,
     catch (error) {
         functionExists = false;
     }
-    const configDirPath = process.cwd(); // TODO: This should be passed from caller
-    const resolvedPath = resolveFunctionDirectory(functionName, configDirPath, functionConfig.dirPath, functionPath);
+    const resolvedConfigDir = configDirPath ?? process.cwd();
+    const resolvedPath = resolveFunctionDirectory(functionName, resolvedConfigDir, functionConfig.dirPath, functionPath);
     if (!validateFunctionDirectory(resolvedPath)) {
         throw new Error(`Function directory is invalid or missing required files: ${resolvedPath}`);
     }

package/dist/functions/fnConfigDiscovery.js

@@ -3,8 +3,8 @@ import path from 'node:path';
 import yaml from 'js-yaml';
 import { homedir } from 'node:os';
 import { AppwriteFunctionSchema } from '@njdamstra/appwrite-utils';
-import { shouldIgnoreDirectory } from '../utils/directoryUtils.js';
-import { MessageFormatter } from '../shared/messageFormatter.js';
+import { shouldIgnoreDirectory } from '@njdamstra/appwrite-utils-helpers';
+import { MessageFormatter } from '@njdamstra/appwrite-utils-helpers';
 function findGitRoot(startDir) {
     let dir = path.resolve(startDir);
     while (dir !== path.parse(dir).root) {

package/dist/functions/methods.js

@@ -2,14 +2,15 @@ import { AppwriteException, Client, Functions, Query, Runtime, } from "node-appw
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import fs from "node:fs";
-import {} from "@njdamstra/appwrite-utils";
+import { EventTypeSchema, } from "@njdamstra/appwrite-utils";
 import chalk from "chalk";
 import { extract as extractTar } from "tar";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-import { expandTildePath, normalizeFunctionName } from "./pathResolution.js";
+import { MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
+import { expandTildePath, normalizeFunctionName } from '@njdamstra/appwrite-utils-helpers';
 /**
  * Validates and filters events array for Appwrite functions
  * - Filters out empty/invalid strings
+ * - Validates against EventTypeSchema
  * - Limits to 100 items maximum (Appwrite limit)
  * - Returns empty array if input is invalid
  */
@@ -17,7 +18,18 @@ const validateEvents = (events) => {
     if (!events || !Array.isArray(events))
         return [];
     return events
-        .filter(event => event && typeof event === 'string' && event.trim().length > 0)
+        .filter(event => {
+        if (!event || typeof event !== 'string' || event.trim().length === 0) {
+            return false;
+        }
+        // Validate against EventTypeSchema
+        const result = EventTypeSchema.safeParse(event);
+        if (!result.success) {
+            MessageFormatter.warning(`Invalid event type "${event}" will be filtered out`, { prefix: "Functions" });
+            return false;
+        }
+        return true;
+    })
         .slice(0, 100);
 };
 export const listFunctions = async (client, queries, search) => {

package/dist/init.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import inquirer from "inquirer";
 import { createEmptyCollection, setupDirsFiles } from "./utils/setupFiles.js";
-import { MessageFormatter } from "./shared/messageFormatter.js";
+import { MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
 MessageFormatter.banner("Appwrite Utils CLI Tool", "For more information, visit https://github.com/njdamstra/AppwriteUtils");
 async function main() {
     const answers = await inquirer.prompt([

package/dist/interactiveCLI.d.ts

@@ -1,9 +1,14 @@
+export interface InteractiveCLIOptions {
+    useSession?: boolean;
+    sessionCookie?: string;
+}
 export declare class InteractiveCLI {
     private currentDir;
     private controller;
     private isUsingTypeScriptConfig;
     private lastSelectedCollectionIds;
-    constructor(currentDir: string);
+    private options;
+    constructor(currentDir: string, options?: InteractiveCLIOptions);
     run(): Promise<void>;
     private initControllerIfNeeded;
     private manageBuckets;