appwrite-utils-cli 0.9.96 → 0.9.98

package/README.md

@@ -125,6 +125,7 @@ This updated CLI ensures that developers have robust tools at their fingertips t
 
 ## Changelog
 
+- 0.9.98: Fixing some import errors reported by users
 - 0.9.95: Updated to include new version of `appwrite-utils`
 - 0.9.93: Updated `selectDatabases` and `selectCollections` from the interactive CLI to prefer local collections or databases when synchronizing the databases
 - 0.9.92: Fixed `createOrUpdateAttributes` so it deletes attributes that don't exist in local config when you are running `syncDb`. Also updated the database and collection selection, so it won't try and fetch the collections and databases that don't exist (ones you picked from local config) and error

package/dist/main.js

@@ -162,20 +162,9 @@ async function main() {
                 options.collections = [];
             }
         }
-        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.doBackup && options.databases) {
+            for (const db of options.databases) {
+                await controller.backupDatabase(db);
             }
         }
         if (options.wipeDatabase ||
@@ -205,9 +194,20 @@ async function main() {
                 }
             }
         }
-        if (options.doBackup && options.databases) {
-            for (const db of options.databases) {
-                await controller.backupDatabase(db);
+        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.generateSchemas) {

package/dist/migrations/dataLoader.d.ts

@@ -79,7 +79,17 @@ export declare const CollectionImportDataSchema: z.ZodObject<{
             key: string;
             type?: "integer" | undefined;
             description?: string | Record<string, string> | null | undefined;
-            required?: boolean | undefined;
+            required
+            /**
+             * Prepares the data for creating user collection documents.
+             * This involves loading the data, transforming it according to the import definition,
+             * and handling the creation of new unique IDs for each item.
+             *
+             * @param db - The database configuration.
+             * @param collection - The collection configuration.
+             * @param importDef - The import definition containing the attribute mappings and other relevant info.
+             */
+            ?: boolean | undefined;
             array?: boolean | undefined;
             error?: string | undefined;
             xdefault?: number | null | undefined;
@@ -674,18 +684,7 @@ export declare const CollectionImportDataSchema: z.ZodObject<{
                 }[] | undefined;
             }[];
             type?: "create" | "update" | undefined;
-            basePath
-            /**
-             * Generates attribute mappings with post-import actions based on the provided attribute mappings.
-             * This method checks each mapping for a fileData attribute and adds a post-import action to create a file
-             * and update the field with the file's ID if necessary.
-             *
-             * @param attributeMappings - The attribute mappings from the import definition.
-             * @param context - The context object containing information about the database, collection, and document.
-             * @param item - The item being imported, used for resolving template paths in fileData mappings.
-             * @returns The attribute mappings updated with any necessary post-import actions.
-             */
-            ?: string | undefined;
+            basePath?: string | undefined;
             idMappings?: {
                 sourceField: string;
                 targetField: string;
@@ -709,7 +708,27 @@ export declare const CollectionImportDataSchema: z.ZodObject<{
         attributes?: ({
             key: string;
             type?: "string" | undefined;
-            format?: string | null | undefined;
+            format
+            /**
+             * Generates attribute mappings with post-import actions based on the provided attribute mappings.
+             * This method checks each mapping for a fileData attribute and adds a post-import action to create a file
+             * and update the field with the file's ID if necessary.
+             *
+             * @param attributeMappings - The attribute mappings from the import definition.
+             * @param context - The context object containing information about the database, collection, and document.
+             * @param item - The item being imported, used for resolving template paths in fileData mappings.
+             * @returns The attribute mappings updated with any necessary post-import actions.
+             */
+            ? /**
+             * Generates attribute mappings with post-import actions based on the provided attribute mappings.
+             * This method checks each mapping for a fileData attribute and adds a post-import action to create a file
+             * and update the field with the file's ID if necessary.
+             *
+             * @param attributeMappings - The attribute mappings from the import definition.
+             * @param context - The context object containing information about the database, collection, and document.
+             * @param item - The item being imported, used for resolving template paths in fileData mappings.
+             * @returns The attribute mappings updated with any necessary post-import actions.
+             */: string | null | undefined;
             description?: string | Record<string, string> | undefined;
             required?: boolean | undefined;
             array?: boolean | undefined;
@@ -1305,18 +1324,7 @@ export declare const CollectionImportDataSchema: z.ZodObject<{
                 }[] | undefined;
             }[];
             type?: "create" | "update" | undefined;
-            basePath
-            /**
-             * Generates attribute mappings with post-import actions based on the provided attribute mappings.
-             * This method checks each mapping for a fileData attribute and adds a post-import action to create a file
-             * and update the field with the file's ID if necessary.
-             *
-             * @param attributeMappings - The attribute mappings from the import definition.
-             * @param context - The context object containing information about the database, collection, and document.
-             * @param item - The item being imported, used for resolving template paths in fileData mappings.
-             * @returns The attribute mappings updated with any necessary post-import actions.
-             */
-            ?: string | undefined;
+            basePath?: string | undefined;
             idMappings?: {
                 sourceField: string;
                 targetField: string;
@@ -1384,7 +1392,27 @@ export declare const CollectionImportDataSchema: z.ZodObject<{
         attributes?: ({
             key: string;
             type?: "string" | undefined;
-            format?: string | null | undefined;
+            format
+            /**
+             * Generates attribute mappings with post-import actions based on the provided attribute mappings.
+             * This method checks each mapping for a fileData attribute and adds a post-import action to create a file
+             * and update the field with the file's ID if necessary.
+             *
+             * @param attributeMappings - The attribute mappings from the import definition.
+             * @param context - The context object containing information about the database, collection, and document.
+             * @param item - The item being imported, used for resolving template paths in fileData mappings.
+             * @returns The attribute mappings updated with any necessary post-import actions.
+             */
+            ? /**
+             * Generates attribute mappings with post-import actions based on the provided attribute mappings.
+             * This method checks each mapping for a fileData attribute and adds a post-import action to create a file
+             * and update the field with the file's ID if necessary.
+             *
+             * @param attributeMappings - The attribute mappings from the import definition.
+             * @param context - The context object containing information about the database, collection, and document.
+             * @param item - The item being imported, used for resolving template paths in fileData mappings.
+             * @returns The attribute mappings updated with any necessary post-import actions.
+             */: string | null | undefined;
             description?: string | Record<string, string> | undefined;
             required?: boolean | undefined;
             array?: boolean | undefined;
@@ -1720,18 +1748,7 @@ export declare class DataLoader {
                     }[] | undefined;
                 }[];
                 type?: "create" | "update" | undefined;
-                basePath
-                /**
-                 * Generates attribute mappings with post-import actions based on the provided attribute mappings.
-                 * This method checks each mapping for a fileData attribute and adds a post-import action to create a file
-                 * and update the field with the file's ID if necessary.
-                 *
-                 * @param attributeMappings - The attribute mappings from the import definition.
-                 * @param context - The context object containing information about the database, collection, and document.
-                 * @param item - The item being imported, used for resolving template paths in fileData mappings.
-                 * @returns The attribute mappings updated with any necessary post-import actions.
-                 */
-                ?: string | undefined;
+                basePath?: string | undefined;
                 idMappings?: {
                     sourceField: string;
                     targetField: string;

package/dist/migrations/dataLoader.js

@@ -147,17 +147,20 @@ export class DataLoader {
     }
     // Method to load data from a file specified in the import definition
     loadData(importDef) {
-        // Resolve the file path and check if the file exists
+        // Simply join appwriteFolderPath with the importDef.filePath
         const filePath = path.resolve(this.appwriteFolderPath, importDef.filePath);
+        console.log(`Loading data from: ${filePath}`); // Add logging
         if (!fs.existsSync(filePath)) {
             console.error(`File not found: ${filePath}`);
             return [];
         }
         // Read the file and parse the JSON data
         const rawData = fs.readFileSync(filePath, "utf8");
-        return importDef.basePath
+        const parsedData = importDef.basePath
             ? JSON.parse(rawData)[importDef.basePath]
             : JSON.parse(rawData);
+        console.log(`Loaded ${parsedData?.length || 0} items from ${filePath}`);
+        return parsedData;
     }
     // Helper method to check if a new ID already exists in the old-to-new ID map
     checkMapValuesForId(newId, collectionName) {
@@ -739,7 +742,7 @@ export class DataLoader {
     async prepareUserCollectionCreateData(db, collection, importDef) {
         // Load the raw data based on the import definition
         const rawData = this.loadData(importDef);
-        const operationId = this.collectionImportOperations.get(this.getCollectionKey(collection.name));
+        let operationId = this.collectionImportOperations.get(this.getCollectionKey(collection.name));
         // Initialize a new map for old ID to new ID mappings
         const oldIdToNewIdMap = new Map();
         // Retrieve or initialize the collection-specific old ID to new ID map
@@ -748,7 +751,10 @@ export class DataLoader {
                 .set(this.getCollectionKey(collection.name), oldIdToNewIdMap)
                 .get(this.getCollectionKey(collection.name));
         if (!operationId) {
-            throw new Error(`No import operation found for collection ${collection.name}`);
+            const collectionImportOperation = await findOrCreateOperation(this.database, collection.$id, "importData");
+            // Store the operation ID in the map
+            this.collectionImportOperations.set(this.getCollectionKey(collection.name), collectionImportOperation.$id);
+            operationId = collectionImportOperation.$id;
         }
         await updateOperation(this.database, operationId, {
             status: "ready",
@@ -892,9 +898,12 @@ export class DataLoader {
     async prepareCreateData(db, collection, importDef) {
         // Load the raw data based on the import definition
         const rawData = this.loadData(importDef);
-        const operationId = this.collectionImportOperations.get(this.getCollectionKey(collection.name));
+        let operationId = this.collectionImportOperations.get(this.getCollectionKey(collection.name));
         if (!operationId) {
-            throw new Error(`No import operation found for collection ${collection.name}`);
+            const collectionImportOperation = await findOrCreateOperation(this.database, collection.$id, "importData");
+            // Store the operation ID in the map
+            this.collectionImportOperations.set(this.getCollectionKey(collection.name), collectionImportOperation.$id);
+            operationId = collectionImportOperation.$id;
         }
         await updateOperation(this.database, operationId, {
             status: "ready",

package/dist/migrations/importController.js

@@ -53,6 +53,7 @@ export class ImportController {
             if (!databaseRan) {
                 databaseRan = db;
                 dataLoader = new DataLoader(this.appwriteFolderPath, this.importDataActions, this.database, this.config, this.setupOptions.shouldWriteFile);
+                await dataLoader.setupMaps(db.$id);
                 await dataLoader.start(db.$id);
                 await this.importCollections(db, dataLoader, specificCollections);
                 await resolveAndUpdateRelationships(db.$id, this.database, this.config);
@@ -80,8 +81,8 @@ export class ImportController {
         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);
+                let isUsersCollection = this.config.usersCollectionName && (dataLoader.getCollectionKey(this.config.usersCollectionName) ===
+                    dataLoader.getCollectionKey(collection.name));
                 const importOperationId = dataLoader.collectionImportOperations.get(dataLoader.getCollectionKey(collection.name));
                 const createBatches = (finalData) => {
                     let maxBatchLength = 50;

package/dist/utils/loadConfigs.js

@@ -53,6 +53,10 @@ export const loadConfig = async (configDir) => {
             const collectionModule = (await import(fileUrl));
             const collection = collectionModule.default?.default || collectionModule.default || collectionModule;
             if (collection) {
+                // Ensure importDefs are properly loaded
+                if (collectionModule.importDefs || collection.importDefs) {
+                    collection.importDefs = collectionModule.importDefs || collection.importDefs;
+                }
                 config.collections.push(collection);
             }
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "appwrite-utils-cli",
   "description": "Appwrite Utility Functions to help with database management, data conversion, data import, migrations, and much more. Meant to be used as a CLI tool, I do not recommend installing this in frontend environments.",
-  "version": "0.9.96",
+  "version": "0.9.98",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/main.ts

@@ -206,27 +206,9 @@ async function main() {
       }
     }
 
-    if (parsedArgv.push || parsedArgv.sync) {
-      const databases =
-        options.databases || (await fetchAllDatabases(controller.database!));
-      let collections: Models.Collection[] = [];
-
-      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.doBackup && options.databases) {
+      for (const db of options.databases) {
+        await controller.backupDatabase(db);
       }
     }
 
@@ -265,12 +247,31 @@ async function main() {
       }
     }
 
-    if (options.doBackup && options.databases) {
-      for (const db of options.databases) {
-        await controller.backupDatabase(db);
+    if (parsedArgv.push || parsedArgv.sync) {
+      const databases =
+        options.databases || (await fetchAllDatabases(controller.database!));
+      let collections: Models.Collection[] = [];
+
+      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.generateSchemas) {
       await controller.generateSchemas();
     }

package/src/migrations/dataLoader.ts

@@ -24,6 +24,7 @@ import { AuthUserCreateSchema } from "../schemas/authUser.js";
 import _ from "lodash";
 import { UsersController } from "./users.js";
 import { finalizeByAttributeMap } from "../utils/helperFunctions.js";
+
 // Define a schema for the structure of collection import data using Zod for validation
 export const CollectionImportDataSchema = z.object({
   // Optional collection creation schema
@@ -182,8 +183,9 @@ export class DataLoader {
 
   // Method to load data from a file specified in the import definition
   loadData(importDef: ImportDef): any[] {
-    // Resolve the file path and check if the file exists
+    // Simply join appwriteFolderPath with the importDef.filePath
     const filePath = path.resolve(this.appwriteFolderPath, importDef.filePath);
+    console.log(`Loading data from: ${filePath}`); // Add logging
     if (!fs.existsSync(filePath)) {
       console.error(`File not found: ${filePath}`);
       return [];
@@ -191,9 +193,12 @@ export class DataLoader {
 
     // Read the file and parse the JSON data
     const rawData = fs.readFileSync(filePath, "utf8");
-    return importDef.basePath
+    const parsedData = importDef.basePath
       ? JSON.parse(rawData)[importDef.basePath]
       : JSON.parse(rawData);
+
+    console.log(`Loaded ${parsedData?.length || 0} items from ${filePath}`);
+    return parsedData;
   }
 
   // Helper method to check if a new ID already exists in the old-to-new ID map
@@ -932,7 +937,7 @@ export class DataLoader {
   ): Promise<void> {
     // Load the raw data based on the import definition
     const rawData = this.loadData(importDef);
-    const operationId = this.collectionImportOperations.get(
+    let operationId = this.collectionImportOperations.get(
       this.getCollectionKey(collection.name)
     );
     // Initialize a new map for old ID to new ID mappings
@@ -946,9 +951,17 @@ export class DataLoader {
         .set(this.getCollectionKey(collection.name), oldIdToNewIdMap)
         .get(this.getCollectionKey(collection.name));
     if (!operationId) {
-      throw new Error(
-        `No import operation found for collection ${collection.name}`
+      const collectionImportOperation = await findOrCreateOperation(
+        this.database,
+        collection.$id,
+        "importData"
       );
+      // Store the operation ID in the map
+      this.collectionImportOperations.set(
+        this.getCollectionKey(collection.name),
+        collectionImportOperation.$id
+      );
+      operationId = collectionImportOperation.$id;
     }
     await updateOperation(this.database, operationId, {
       status: "ready",
@@ -1160,13 +1173,21 @@ export class DataLoader {
   ): Promise<void> {
     // Load the raw data based on the import definition
     const rawData = this.loadData(importDef);
-    const operationId = this.collectionImportOperations.get(
+    let operationId = this.collectionImportOperations.get(
       this.getCollectionKey(collection.name)
     );
     if (!operationId) {
-      throw new Error(
-        `No import operation found for collection ${collection.name}`
+      const collectionImportOperation = await findOrCreateOperation(
+        this.database,
+        collection.$id,
+        "importData"
+      );
+      // Store the operation ID in the map
+      this.collectionImportOperations.set(
+        this.getCollectionKey(collection.name),
+        collectionImportOperation.$id
       );
+      operationId = collectionImportOperation.$id;
     }
     await updateOperation(this.database, operationId, {
       status: "ready",

package/src/migrations/importController.ts

@@ -100,6 +100,7 @@ export class ImportController {
           this.config,
           this.setupOptions.shouldWriteFile
         );
+        await dataLoader.setupMaps(db.$id);
         await dataLoader.start(db.$id);
         await this.importCollections(db, dataLoader, specificCollections);
         await resolveAndUpdateRelationships(db.$id, this.database, this.config);
@@ -147,9 +148,8 @@ export class ImportController {
 
     for (const collection of this.config.collections || []) {
       if (collectionsToImport.includes(collection.name)) {
-        let isUsersCollection =
-          dataLoader.getCollectionKey(this.config.usersCollectionName) ===
-          dataLoader.getCollectionKey(collection.name);
+        let isUsersCollection = this.config.usersCollectionName && (dataLoader.getCollectionKey(this.config.usersCollectionName) ===
+            dataLoader.getCollectionKey(collection.name));
         const importOperationId = dataLoader.collectionImportOperations.get(
           dataLoader.getCollectionKey(collection.name)
         );

package/src/utils/loadConfigs.ts

@@ -60,6 +60,10 @@ export const loadConfig = async (
       const collectionModule = (await import(fileUrl));
       const collection: Collection | undefined = collectionModule.default?.default || collectionModule.default || collectionModule;
       if (collection) {
+        // Ensure importDefs are properly loaded
+        if (collectionModule.importDefs || collection.importDefs) {
+          collection.importDefs = collectionModule.importDefs || collection.importDefs;
+        }
         config.collections.push(collection);
       }
     }

package/src/utilsController.ts

@@ -253,7 +253,6 @@ export class UtilsController {
       options,
       options.databases
     );
-
     await importController.run(options.collections);
   }
 

package/tsconfig.json

@@ -33,5 +33,5 @@
     "declaration": true
   },
   "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "src/_test/appwrite", "example/*"]
+  "exclude": ["node_modules", "dist", "src/appwrite", "src/_test/appwrite", "example/*"]
 }

package/dist/appwrite/appwriteConfig.d.ts

@@ -1,3 +0,0 @@
-import { type AppwriteConfig } from "appwrite-utils";
-declare const appwriteConfig: AppwriteConfig;
-export default appwriteConfig;

package/dist/appwrite/appwriteConfig.js

@@ -1,40 +0,0 @@
-import {} from "appwrite-utils";
-const appwriteConfig = {
-    appwriteEndpoint: "https://appwrite.blackleafdigital.com/v1",
-    appwriteProject: "6717441100056a90bb20",
-    appwriteKey: "standard_f8664be4666240926caa1a2ed15a87424948036e3fd47b8d99a3de0cad83cdea7309ae30d004a3edd44c45292605f4a6b9c654aa44924a7cc5e3e95a77e0c9513d9c29a9059b7cf4fdafe626b67147d26de78390f946aeca22328f7ebdcdad159a644eb7589cacecdf4e397bd51362230cd319544a804db62d8edb968de1392a",
-    enableBackups: true,
-    backupInterval: 3600,
-    backupRetention: 30,
-    enableBackupCleanup: true,
-    enableMockData: false,
-    documentBucketId: "documents",
-    usersCollectionName: "Members",
-    databases: [
-        {
-            $id: "main",
-            name: "Main",
-            bucket: {
-                $id: "main_bucket",
-                name: "Main Bucket",
-                enabled: true,
-                maximumFileSize: 30000000,
-                allowedFileExtensions: [],
-                encryption: true,
-                antivirus: true
-            }
-        },
-    ],
-    buckets: [
-        {
-            $id: "global_bucket",
-            name: "Global Bucket",
-            enabled: true,
-            maximumFileSize: 30000000,
-            allowedFileExtensions: [],
-            encryption: true,
-            antivirus: true
-        }
-    ]
-};
-export default appwriteConfig;

package/dist/appwrite/collections/Album.d.ts

@@ -1,3 +0,0 @@
-import type { CollectionCreate } from "appwrite-utils";
-declare const Album: Partial<CollectionCreate>;
-export default Album;

package/dist/appwrite/collections/Album.js

@@ -1,58 +0,0 @@
-const Album = {
-    $id: '01JASDQZ5TXZZ1Z9EVR5PKC10G',
-    documentSecurity: false,
-    enabled: true,
-    name: 'Album',
-    $permissions: [
-        { permission: 'read', target: 'any' },
-        { permission: 'create', target: 'users' },
-        { permission: 'update', target: 'users' },
-        { permission: 'delete', target: 'users' }
-    ],
-    attributes: [
-        {
-            key: 'title',
-            type: 'string',
-            size: 256,
-            required: true,
-        },
-        {
-            key: 'artistId',
-            type: 'string',
-            size: 36,
-            required: true,
-        },
-        {
-            key: 'releaseDate',
-            type: 'float',
-            min: 0,
-            required: true,
-        },
-        {
-            key: 'coverArtId',
-            type: 'string',
-            size: 36,
-            required: false,
-        },
-        {
-            key: 'genreIds',
-            type: 'string',
-            size: 36,
-            array: true,
-            required: false,
-        },
-    ],
-    indexes: [
-        {
-            key: 'title',
-            type: 'fulltext',
-            attributes: ['title'],
-        },
-        {
-            key: 'artistId',
-            type: 'key',
-            attributes: ['artistId'],
-        },
-    ],
-};
-export default Album;

package/dist/appwrite/collections/Artist.d.ts

@@ -1,3 +0,0 @@
-import type { CollectionCreate } from "appwrite-utils";
-declare const Artist: Partial<CollectionCreate>;
-export default Artist;