appwrite-utils-cli 0.9.77 → 0.9.79

package/dist/main.js

@@ -6,6 +6,9 @@ import { InteractiveCLI } from "./interactiveCLI.js";
 import { UtilsController } from "./utilsController.js";
 import { Databases, Storage } from "node-appwrite";
 import { getClient } from "./utils/getClientFromConfig.js";
+import { fetchAllDatabases } from "./migrations/databases.js";
+import { setupDirsFiles } from "./utils/setupFiles.js";
+import { fetchAllCollections } from "./collections/methods.js";
 const argv = yargs(hideBin(process.argv))
     .option("it", {
     alias: ["interactive", "i"],
@@ -28,6 +31,10 @@ const argv = yargs(hideBin(process.argv))
     .option("wipe", {
     choices: ["all", "docs", "users"],
     description: "Wipe data (all: everything, docs: only documents, users: only user data)",
+})
+    .option("wipeCollections", {
+    type: "boolean",
+    description: "Wipe collections, uses collectionIds option to get the collections to wipe",
 })
     .option("generate", {
     type: "boolean",
@@ -90,78 +97,79 @@ const argv = yargs(hideBin(process.argv))
     description: "Set the destination collection ID for transfer",
 })
     .option("fromBucketId", {
-    alias: ["fromBucket"],
     type: "string",
     description: "Set the source bucket ID for transfer",
 })
     .option("toBucketId", {
-    alias: ["toBucket"],
     type: "string",
     description: "Set the destination bucket ID for transfer",
 })
     .option("remoteEndpoint", {
     type: "string",
-    description: "Set the remote Appwrite endpoint for transfers",
+    description: "Set the remote Appwrite endpoint for transfer",
 })
     .option("remoteProjectId", {
     type: "string",
-    description: "Set the remote Appwrite project ID for transfers",
+    description: "Set the remote Appwrite project ID for transfer",
 })
     .option("remoteApiKey", {
     type: "string",
-    description: "Set the remote Appwrite API key for transfers",
+    description: "Set the remote Appwrite API key for transfer",
 })
     .option("setup", {
     type: "boolean",
-    description: "Setup the project with example data",
+    description: "Setup directories and files",
 })
-    .help()
     .parse();
 async function main() {
-    const parsedArgv = (await argv);
-    let controller;
-    if (parsedArgv.it) {
-        try {
-            controller = new UtilsController(process.cwd());
-            await controller.init();
-        }
-        catch (error) {
-            // If it fails, that means there's no config, more than likely
-            console.log("No config found, you probably need to create the setup files");
-        }
+    const controller = new UtilsController(process.cwd());
+    if (argv.it) {
         const cli = new InteractiveCLI(process.cwd());
         await cli.run();
     }
     else {
-        if (!controller) {
-            controller = new UtilsController(process.cwd());
-            await controller.init();
+        await controller.init();
+        if (argv.setup) {
+            await setupDirsFiles(false, process.cwd());
+            return;
         }
-        // Handle non-interactive mode with the new options
+        const parsedArgv = argv;
         const options = {
             databases: parsedArgv.dbIds
-                ? await controller.getDatabasesByIds(parsedArgv.dbIds.replace(" ", "").split(","))
-                : undefined,
-            collections: parsedArgv.collectionIds
-                ? parsedArgv.collectionIds.replace(" ", "").split(",")
+                ? await controller.getDatabasesByIds(parsedArgv.dbIds.split(","))
                 : undefined,
+            collections: parsedArgv.collectionIds?.split(","),
             doBackup: parsedArgv.backup,
             wipeDatabase: parsedArgv.wipe === "all" || parsedArgv.wipe === "docs",
             wipeDocumentStorage: parsedArgv.wipe === "all",
             wipeUsers: parsedArgv.wipe === "all" || parsedArgv.wipe === "users",
             generateSchemas: parsedArgv.generate,
             importData: parsedArgv.import,
-            checkDuplicates: false,
             shouldWriteFile: parsedArgv.writeData,
+            wipeCollections: parsedArgv.wipeCollections,
         };
-        if (parsedArgv.push) {
-            await controller.syncDb();
+        if (parsedArgv.push || parsedArgv.sync) {
+            const databases = options.databases || await fetchAllDatabases(controller.database);
+            let collections = [];
+            if (options.collections) {
+                for (const db of databases) {
+                    const dbCollections = await fetchAllCollections(db.$id, controller.database);
+                    collections = collections.concat(dbCollections.filter(c => options.collections.includes(c.$id)));
+                }
+            }
+            if (parsedArgv.push) {
+                await controller.syncDb(databases, collections);
+            }
+            else if (parsedArgv.sync) {
+                await controller.synchronizeConfigurations(databases);
+            }
         }
         if (options.wipeDatabase ||
             options.wipeDocumentStorage ||
-            options.wipeUsers) {
-            if (options.wipeDatabase) {
-                for (const db of options.databases || []) {
+            options.wipeUsers ||
+            options.wipeCollections) {
+            if (options.wipeDatabase && options.databases) {
+                for (const db of options.databases) {
                     await controller.wipeDatabase(db);
                 }
             }
@@ -173,9 +181,18 @@ async function main() {
             if (options.wipeUsers) {
                 await controller.wipeUsers();
             }
+            if (options.wipeCollections && options.databases) {
+                for (const db of options.databases) {
+                    const dbCollections = await fetchAllCollections(db.$id, controller.database);
+                    const collectionsToWipe = dbCollections.filter(c => options.collections.includes(c.$id));
+                    for (const collection of collectionsToWipe) {
+                        await controller.wipeCollection(db, collection);
+                    }
+                }
+            }
         }
-        if (options.doBackup) {
-            for (const db of options.databases || []) {
+        if (options.doBackup && options.databases) {
+            for (const db of options.databases) {
                 await controller.backupDatabase(db);
             }
         }
@@ -200,8 +217,8 @@ async function main() {
                 const remoteClient = getClient(parsedArgv.remoteEndpoint, parsedArgv.remoteProjectId, parsedArgv.remoteApiKey);
                 targetDatabases = new Databases(remoteClient);
                 targetStorage = new Storage(remoteClient);
-                const remoteDbs = await targetDatabases.list();
-                toDb = remoteDbs.databases.find((db) => db.$id === parsedArgv.toDbId);
+                const remoteDbs = await fetchAllDatabases(targetDatabases);
+                toDb = remoteDbs.find((db) => db.$id === parsedArgv.toDbId);
             }
             else {
                 toDb = (await controller.getDatabasesByIds([parsedArgv.toDbId]))[0];
@@ -233,9 +250,6 @@ async function main() {
             };
             await controller.transferData(transferOptions);
         }
-        if (parsedArgv.sync) {
-            await controller.synchronizeConfigurations(options.databases);
-        }
     }
 }
 main().catch((error) => {

package/dist/migrations/importController.d.ts

@@ -16,8 +16,8 @@ export declare class ImportController {
     private postImportActionsQueue;
     private databasesToRun;
     constructor(config: AppwriteConfig, database: Databases, storage: Storage, appwriteFolderPath: string, importDataActions: ImportDataActions, setupOptions: SetupOptions, databasesToRun?: Models.Database[]);
-    run(): Promise<void>;
+    run(specificCollections?: string[]): Promise<void>;
     updateOthersToFinalData(updatedDb: Models.Database, targetDb: Models.Database): Promise<void>;
-    importCollections(db: ConfigDatabase, dataLoader: DataLoader): Promise<void>;
-    executePostImportActions(dbId: string, dataLoader: DataLoader): Promise<void>;
+    importCollections(db: ConfigDatabase, dataLoader: DataLoader, specificCollections?: string[]): Promise<void>;
+    executePostImportActions(dbId: string, dataLoader: DataLoader, specificCollections?: string[]): Promise<void>;
 }

package/dist/migrations/importController.js

@@ -30,7 +30,7 @@ export class ImportController {
         this.documentCache = new Map();
         this.databasesToRun = databasesToRun || [];
     }
-    async run() {
+    async run(specificCollections) {
         let databasesToProcess;
         if (this.databasesToRun.length > 0) {
             // Use the provided databases
@@ -54,9 +54,9 @@ export class ImportController {
                 databaseRan = db;
                 dataLoader = new DataLoader(this.appwriteFolderPath, this.importDataActions, this.database, this.config, this.setupOptions.shouldWriteFile);
                 await dataLoader.start(db.$id);
-                await this.importCollections(db, dataLoader);
+                await this.importCollections(db, dataLoader, specificCollections);
                 await resolveAndUpdateRelationships(db.$id, this.database, this.config);
-                await this.executePostImportActions(db.$id, dataLoader);
+                await this.executePostImportActions(db.$id, dataLoader, specificCollections);
             }
             else if (databaseRan.$id !== db.$id) {
                 await this.updateOthersToFinalData(databaseRan, db);
@@ -76,170 +76,147 @@ export class ImportController {
             await transferStorageLocalToLocal(this.storage, updatedDbConfig.bucket.$id, targetDbConfig.bucket.$id);
         }
     }
-    async importCollections(db, dataLoader) {
-        if (!this.config.collections) {
-            return;
-        }
-        for (const collection of this.config.collections) {
-            let isUsersCollection = dataLoader.getCollectionKey(this.config.usersCollectionName) ===
-                dataLoader.getCollectionKey(collection.name);
-            const importOperationId = dataLoader.collectionImportOperations.get(dataLoader.getCollectionKey(collection.name));
-            const createBatches = (finalData) => {
-                let maxBatchLength = 100;
-                const finalBatches = [];
-                for (let i = 0; i < finalData.length; i++) {
-                    if (i % maxBatchLength === 0) {
-                        finalBatches.push([]);
+    async importCollections(db, dataLoader, specificCollections) {
+        const collectionsToImport = specificCollections || (this.config.collections ? this.config.collections.map(c => c.name) : []);
+        for (const collection of this.config.collections || []) {
+            if (collectionsToImport.includes(collection.name)) {
+                let isUsersCollection = dataLoader.getCollectionKey(this.config.usersCollectionName) ===
+                    dataLoader.getCollectionKey(collection.name);
+                const importOperationId = dataLoader.collectionImportOperations.get(dataLoader.getCollectionKey(collection.name));
+                const createBatches = (finalData) => {
+                    let maxBatchLength = 100;
+                    const finalBatches = [];
+                    for (let i = 0; i < finalData.length; i++) {
+                        if (i % maxBatchLength === 0) {
+                            finalBatches.push([]);
+                        }
+                        finalBatches[finalBatches.length - 1].push(finalData[i]);
                     }
-                    finalBatches[finalBatches.length - 1].push(finalData[i]);
-                }
-                return finalBatches;
-            };
-            if (isUsersCollection && !this.hasImportedUsers) {
-                const usersDataMap = dataLoader.importMap.get(dataLoader.getCollectionKey("users"));
-                const usersData = usersDataMap?.data;
-                const usersController = new UsersController(this.config, this.database);
-                if (usersData) {
-                    console.log("Found users data", usersData.length);
-                    const userDataBatches = createBatches(usersData);
-                    for (const batch of userDataBatches) {
-                        console.log("Importing users batch", batch.length);
-                        const userBatchPromises = batch
-                            .filter((item) => {
-                            let itemId;
-                            if (item.finalData.userId) {
-                                itemId = item.finalData.userId;
-                            }
-                            else if (item.finalData.docId) {
-                                itemId = item.finalData.docId;
-                            }
-                            if (!itemId) {
-                                return false;
-                            }
-                            return (item &&
-                                item.finalData &&
-                                !dataLoader.userExistsMap.has(itemId));
-                        })
-                            .map((item) => {
-                            dataLoader.userExistsMap.set(item.finalData.userId ||
-                                item.finalData.docId ||
-                                item.context.userId ||
-                                item.context.docId, true);
-                            return usersController.createUserAndReturn(item.finalData);
-                        });
-                        const promiseResults = await Promise.allSettled(userBatchPromises);
-                        for (const item of batch) {
-                            if (item && item.finalData) {
+                    return finalBatches;
+                };
+                if (isUsersCollection && !this.hasImportedUsers) {
+                    const usersDataMap = dataLoader.importMap.get(dataLoader.getCollectionKey("users"));
+                    const usersData = usersDataMap?.data;
+                    const usersController = new UsersController(this.config, this.database);
+                    if (usersData) {
+                        console.log("Found users data", usersData.length);
+                        const userDataBatches = createBatches(usersData);
+                        for (const batch of userDataBatches) {
+                            console.log("Importing users batch", batch.length);
+                            const userBatchPromises = batch
+                                .filter((item) => {
+                                let itemId;
+                                if (item.finalData.userId) {
+                                    itemId = item.finalData.userId;
+                                }
+                                else if (item.finalData.docId) {
+                                    itemId = item.finalData.docId;
+                                }
+                                if (!itemId) {
+                                    return false;
+                                }
+                                return (item &&
+                                    item.finalData &&
+                                    !dataLoader.userExistsMap.has(itemId));
+                            })
+                                .map((item) => {
                                 dataLoader.userExistsMap.set(item.finalData.userId ||
                                     item.finalData.docId ||
                                     item.context.userId ||
                                     item.context.docId, true);
+                                return usersController.createUserAndReturn(item.finalData);
+                            });
+                            const promiseResults = await Promise.allSettled(userBatchPromises);
+                            for (const item of batch) {
+                                if (item && item.finalData) {
+                                    dataLoader.userExistsMap.set(item.finalData.userId ||
+                                        item.finalData.docId ||
+                                        item.context.userId ||
+                                        item.context.docId, true);
+                                }
                             }
+                            console.log("Finished importing users batch");
                         }
-                        console.log("Finished importing users batch");
+                        this.hasImportedUsers = true;
+                        console.log("Finished importing users");
                     }
-                    this.hasImportedUsers = true;
-                    console.log("Finished importing users");
                 }
-            }
-            if (!importOperationId) {
-                // Skip further processing if no import operation is found
-                continue;
-            }
-            const importOperation = await this.database.getDocument("migrations", "currentOperations", importOperationId);
-            await updateOperation(this.database, importOperation.$id, {
-                status: "in_progress",
-            });
-            const collectionData = dataLoader.importMap.get(dataLoader.getCollectionKey(collection.name));
-            console.log(`Processing collection: ${collection.name}...`);
-            if (!collectionData) {
-                console.log("No collection data for ", collection.name);
-                continue;
-            }
-            const dataSplit = createBatches(collectionData.data);
-            let processedItems = 0;
-            for (let i = 0; i < dataSplit.length; i++) {
-                const batches = dataSplit[i];
-                console.log(`Processing batch ${i + 1} of ${dataSplit.length}`);
-                // const documentExistsPromises = batches.map(async (item) => {
-                //   try {
-                //     const id =
-                //       item.finalData.docId ||
-                //       item.finalData.userId ||
-                //       item.context.docId ||
-                //       item.context.userId;
-                //     if (!item.finalData) {
-                //       return Promise.resolve(null);
-                //     }
-                //     return tryAwaitWithRetry(
-                //       async () =>
-                //         await documentExists(
-                //           this.database,
-                //           db.$id,
-                //           collection.$id,
-                //           item.finalData
-                //         )
-                //     );
-                //   } catch (error) {
-                //     console.error(error);
-                //     return Promise.resolve(null);
-                //   }
-                // });
-                // const documentExistsResults = await Promise.all(documentExistsPromises);
-                const batchPromises = batches.map((item, index) => {
-                    try {
-                        const id = item.finalData.docId ||
-                            item.finalData.userId ||
-                            item.context.docId ||
-                            item.context.userId;
-                        if (item.finalData.hasOwnProperty("userId")) {
-                            delete item.finalData.userId;
-                        }
-                        if (item.finalData.hasOwnProperty("docId")) {
-                            delete item.finalData.docId;
+                if (!importOperationId) {
+                    // Skip further processing if no import operation is found
+                    continue;
+                }
+                const importOperation = await this.database.getDocument("migrations", "currentOperations", importOperationId);
+                await updateOperation(this.database, importOperation.$id, {
+                    status: "in_progress",
+                });
+                const collectionData = dataLoader.importMap.get(dataLoader.getCollectionKey(collection.name));
+                console.log(`Processing collection: ${collection.name}...`);
+                if (!collectionData) {
+                    console.log("No collection data for ", collection.name);
+                    continue;
+                }
+                const dataSplit = createBatches(collectionData.data);
+                let processedItems = 0;
+                for (let i = 0; i < dataSplit.length; i++) {
+                    const batches = dataSplit[i];
+                    console.log(`Processing batch ${i + 1} of ${dataSplit.length}`);
+                    const batchPromises = batches.map((item, index) => {
+                        try {
+                            const id = item.finalData.docId ||
+                                item.finalData.userId ||
+                                item.context.docId ||
+                                item.context.userId;
+                            if (item.finalData.hasOwnProperty("userId")) {
+                                delete item.finalData.userId;
+                            }
+                            if (item.finalData.hasOwnProperty("docId")) {
+                                delete item.finalData.docId;
+                            }
+                            if (!item.finalData) {
+                                return Promise.resolve();
+                            }
+                            return tryAwaitWithRetry(async () => await this.database.createDocument(db.$id, collection.$id, id, item.finalData));
                         }
-                        if (!item.finalData) {
+                        catch (error) {
+                            console.error(error);
                             return Promise.resolve();
                         }
-                        return tryAwaitWithRetry(async () => await this.database.createDocument(db.$id, collection.$id, id, item.finalData));
-                    }
-                    catch (error) {
-                        console.error(error);
-                        return Promise.resolve();
-                    }
-                });
-                // Wait for all promises in the current batch to resolve
-                await Promise.all(batchPromises);
-                console.log(`Completed batch ${i + 1} of ${dataSplit.length}`);
+                    });
+                    // Wait for all promises in the current batch to resolve
+                    await Promise.all(batchPromises);
+                    console.log(`Completed batch ${i + 1} of ${dataSplit.length}`);
+                    await updateOperation(this.database, importOperation.$id, {
+                        progress: processedItems,
+                    });
+                }
+                // After all batches are processed, update the operation status to completed
                 await updateOperation(this.database, importOperation.$id, {
-                    progress: processedItems,
+                    status: "completed",
                 });
             }
-            // After all batches are processed, update the operation status to completed
-            await updateOperation(this.database, importOperation.$id, {
-                status: "completed",
-            });
         }
     }
-    async executePostImportActions(dbId, dataLoader) {
+    async executePostImportActions(dbId, dataLoader, specificCollections) {
+        const collectionsToProcess = specificCollections || Array.from(dataLoader.importMap.keys());
         // Iterate over each collection in the importMap
-        for (const [collectionKey, collectionData,] of dataLoader.importMap.entries()) {
-            console.log(`Processing post-import actions for collection: ${collectionKey}`);
-            // Iterate over each item in the collectionData.data
-            for (const item of collectionData.data) {
-                // Assuming each item has attributeMappings that contain actions to be executed
-                if (item.importDef && item.importDef.attributeMappings) {
-                    // Use item.context as the context for action execution
-                    const context = item.context; // Directly use item.context as the context for action execution
-                    // Iterate through attributeMappings to execute actions
-                    try {
-                        // Execute post-import actions for the current attributeMapping
-                        // Pass item.finalData as the data to be processed along with the context
-                        await this.importDataActions.executeAfterImportActions(item.finalData, item.importDef.attributeMappings, context);
-                    }
-                    catch (error) {
-                        console.error(`Failed to execute post-import actions for item in collection ${collectionKey}:`, error);
-                        // Handle error (e.g., log, retry, continue with next action)
+        for (const [collectionKey, collectionData] of dataLoader.importMap.entries()) {
+            if (collectionsToProcess.includes(collectionKey)) {
+                console.log(`Processing post-import actions for collection: ${collectionKey}`);
+                // Iterate over each item in the collectionData.data
+                for (const item of collectionData.data) {
+                    // Assuming each item has attributeMappings that contain actions to be executed
+                    if (item.importDef && item.importDef.attributeMappings) {
+                        // Use item.context as the context for action execution
+                        const context = item.context; // Directly use item.context as the context for action execution
+                        // Iterate through attributeMappings to execute actions
+                        try {
+                            // Execute post-import actions for the current attributeMapping
+                            // Pass item.finalData as the data to be processed along with the context
+                            await this.importDataActions.executeAfterImportActions(item.finalData, item.importDef.attributeMappings, context);
+                        }
+                        catch (error) {
+                            console.error(`Failed to execute post-import actions for item in collection ${collectionKey}:`, error);
+                        }
                     }
                 }
             }

package/dist/migrations/setupDatabase.d.ts

@@ -1,5 +1,6 @@
 import { Databases, type Models } from "node-appwrite";
 import { type AppwriteConfig } from "appwrite-utils";
 export declare const setupMigrationDatabase: (config: AppwriteConfig) => Promise<void>;
-export declare const ensureDatabasesExist: (config: AppwriteConfig) => Promise<void>;
+export declare const ensureDatabasesExist: (config: AppwriteConfig, databasesToEnsure?: Models.Database[]) => Promise<void>;
 export declare const wipeOtherDatabases: (database: Databases, databasesToKeep: Models.Database[]) => Promise<void>;
+export declare const ensureCollectionsExist: (config: AppwriteConfig, database: Models.Database, collectionsToEnsure?: Models.Collection[]) => Promise<void>;

package/dist/migrations/setupDatabase.js

@@ -9,6 +9,9 @@ export const setupMigrationDatabase = async (config) => {
     console.log("Starting Migrations Setup");
     console.log("---------------------------------");
     const database = new Databases(config.appwriteClient);
+    if (!config.appwriteClient) {
+        throw new Error("Appwrite client is not initialized in the config");
+    }
     let db;
     const migrationCollectionsSetup = getMigrationCollectionSchemas();
     try {
@@ -60,16 +63,23 @@ export const setupMigrationDatabase = async (config) => {
     console.log("Migrations Setup Complete");
     console.log("---------------------------------");
 };
-export const ensureDatabasesExist = async (config) => {
+export const ensureDatabasesExist = async (config, databasesToEnsure) => {
+    if (!config.appwriteClient) {
+        throw new Error("Appwrite client is not initialized in the config");
+    }
     const database = new Databases(config.appwriteClient);
-    const databasesToEnsure = config.databases;
+    const databasesToCreate = databasesToEnsure || config.databases || [];
+    if (!databasesToCreate.length) {
+        console.log("No databases to create");
+        return;
+    }
     const existingDatabases = await tryAwaitWithRetry(async () => await database.list([Query.limit(500)]));
     const migrationsDatabase = existingDatabases.databases.find((d) => d.name.toLowerCase().trim().replace(" ", "") === "migrations");
     if (existingDatabases.databases.length !== 0 && migrationsDatabase) {
         console.log("Creating all databases except migrations");
-        databasesToEnsure.push(migrationsDatabase);
+        databasesToCreate.push(migrationsDatabase);
     }
-    for (const db of databasesToEnsure) {
+    for (const db of databasesToCreate) {
         if (!existingDatabases.databases.some((d) => d.name === db.name)) {
             await tryAwaitWithRetry(async () => await database.create(db.$id || ulid(), db.name, true));
             console.log(`${db.name} database created`);
@@ -77,7 +87,7 @@ export const ensureDatabasesExist = async (config) => {
     }
 };
 export const wipeOtherDatabases = async (database, databasesToKeep) => {
-    console.log(`Databases to keep: ${databasesToKeep.join(", ")}`);
+    console.log(`Databases to keep: ${databasesToKeep.map(db => db.name).join(", ")}`);
     const allDatabases = await tryAwaitWithRetry(async () => await database.list([Query.limit(500)]));
     const migrationsDatabase = allDatabases.databases.find((d) => d.name.toLowerCase().trim().replace(" ", "") === "migrations");
     if (allDatabases.databases.length !== 0 && migrationsDatabase) {
@@ -91,3 +101,15 @@ export const wipeOtherDatabases = async (database, databasesToKeep) => {
         }
     }
 };
+export const ensureCollectionsExist = async (config, database, collectionsToEnsure) => {
+    const databaseClient = new Databases(config.appwriteClient);
+    const collectionsToCreate = collectionsToEnsure ||
+        (config.collections ? config.collections : []);
+    const existingCollections = await tryAwaitWithRetry(async () => await databaseClient.listCollections(database.$id, [Query.limit(500)]));
+    for (const collection of collectionsToCreate) {
+        if (!existingCollections.collections.some((c) => c.name === collection.name)) {
+            await tryAwaitWithRetry(async () => await databaseClient.createCollection(database.$id, ulid(), collection.name, undefined, true, true));
+            console.log(`${collection.name} collection created in ${database.name}`);
+        }
+    }
+};

package/dist/storage/methods.js

@@ -74,7 +74,10 @@ export const ensureDatabaseConfigBucketsExist = async (storage, config, database
                     console.log(`Bucket ${database.bucket.$id} created successfully.`);
                 }
                 catch (createError) {
-                    console.error(`Failed to create bucket ${database.bucket.$id}:`, createError);
+                    // console.error(
+                    //   `Failed to create bucket ${database.bucket.$id}:`,
+                    //   createError
+                    // );
                 }
             }
         }

package/dist/utils/setupFiles.js

@@ -71,10 +71,13 @@ const baseConfig = {
 const collectionsConfig = [
     {
         name: "ExampleCollection",
-        content: `import { CollectionCreate } from "appwrite-utils";
+        content: `import type { CollectionCreate } from "appwrite-utils";
     
 const ExampleCollection: Partial<CollectionCreate> = {
   name: 'ExampleCollection',
+  $id: '${ulid()}',
+  documentSecurity: false,
+  enabled: true,
   $permissions: [
     { permission: 'read', target: 'any' },
     { permission: 'create', target: 'users' },