appwrite-utils-cli 1.3.5 → 1.4.0

package/dist/shared/migrationHelpers.d.ts

@@ -17,154 +17,52 @@ export declare const ContextObject: z.ZodObject<{
     finalItem: z.ZodAny;
     attributeMappings: z.ZodArray<z.ZodObject<{
         oldKey: z.ZodOptional<z.ZodString>;
-        oldKeys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        oldKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
         targetKey: z.ZodString;
         valueToSet: z.ZodOptional<z.ZodAny>;
         fileData: z.ZodOptional<z.ZodObject<{
             name: z.ZodString;
             path: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            path: string;
-            name: string;
-        }, {
-            path: string;
-            name: string;
-        }>>;
-        converters: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString, "many">>>;
+        }, z.core.$strip>>;
+        converters: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
         validationActions: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodObject<{
             action: z.ZodString;
-            params: z.ZodArray<z.ZodString, "many">;
-        }, "strip", z.ZodTypeAny, {
-            params: string[];
-            action: string;
-        }, {
-            params: string[];
-            action: string;
-        }>, "many">>>;
+            params: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>>>;
         postImportActions: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodObject<{
             action: z.ZodString;
-            params: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            params: (string | Record<string, any>)[];
-            action: string;
-        }, {
-            params: (string | Record<string, any>)[];
-            action: string;
-        }>, "many">>>;
-    }, "strip", z.ZodTypeAny, {
-        targetKey: string;
-        oldKey?: string | undefined;
-        oldKeys?: string[] | undefined;
-        valueToSet?: any;
-        fileData?: {
-            path: string;
-            name: string;
-        } | undefined;
-        converters?: string[] | undefined;
-        validationActions?: {
-            params: string[];
-            action: string;
-        }[] | undefined;
-        postImportActions?: {
-            params: (string | Record<string, any>)[];
-            action: string;
-        }[] | undefined;
-    }, {
-        targetKey: string;
-        oldKey?: string | undefined;
-        oldKeys?: string[] | undefined;
-        valueToSet?: any;
-        fileData?: {
-            path: string;
-            name: string;
-        } | undefined;
-        converters?: string[] | undefined;
-        validationActions?: {
-            params: string[];
-            action: string;
-        }[] | undefined;
-        postImportActions?: {
-            params: (string | Record<string, any>)[];
-            action: string;
-        }[] | undefined;
-    }>, "many">;
+            params: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
+        }, z.core.$strip>>>>;
+    }, z.core.$strip>>;
     context: z.ZodAny;
-}, "strip", z.ZodTypeAny, {
-    collectionId: string;
-    attributeMappings: {
-        targetKey: string;
-        oldKey?: string | undefined;
-        oldKeys?: string[] | undefined;
-        valueToSet?: any;
-        fileData?: {
-            path: string;
-            name: string;
-        } | undefined;
-        converters?: string[] | undefined;
-        validationActions?: {
-            params: string[];
-            action: string;
-        }[] | undefined;
-        postImportActions?: {
-            params: (string | Record<string, any>)[];
-            action: string;
-        }[] | undefined;
-    }[];
-    dbId: string;
-    context?: any;
-    finalItem?: any;
-}, {
-    collectionId: string;
-    attributeMappings: {
-        targetKey: string;
-        oldKey?: string | undefined;
-        oldKeys?: string[] | undefined;
-        valueToSet?: any;
-        fileData?: {
-            path: string;
-            name: string;
-        } | undefined;
-        converters?: string[] | undefined;
-        validationActions?: {
-            params: string[];
-            action: string;
-        }[] | undefined;
-        postImportActions?: {
-            params: (string | Record<string, any>)[];
-            action: string;
-        }[] | undefined;
-    }[];
-    dbId: string;
-    context?: any;
-    finalItem?: any;
-}>;
+}, z.core.$strip>;
 export type ContextObject = z.infer<typeof ContextObject>;
 export declare const createOrFindAfterImportOperation: (database: Databases, collectionId: string, context: ContextObject, useMigrations?: boolean) => Promise<void>;
 export declare const addBatch: (database: Databases, data: string) => Promise<string>;
 export declare const getAfterImportOperations: (database: Databases, collectionId: string, useMigrations?: boolean) => Promise<{
-    status: "error" | "pending" | "ready" | "in_progress" | "completed" | "cancelled";
-    error: string;
     $id: string;
     $createdAt: string;
     $updatedAt: string;
-    collectionId: string;
     operationType: string;
+    collectionId: string;
+    data: any;
     progress: number;
     total: number;
-    data?: any;
+    error: string;
+    status: "error" | "pending" | "ready" | "in_progress" | "completed" | "cancelled";
     batches?: string[] | undefined;
 }[]>;
 export declare const findOrCreateOperation: (database: Databases, collectionId: string, operationType: string, additionalQueries?: string[]) => Promise<{
-    status: "error" | "pending" | "ready" | "in_progress" | "completed" | "cancelled";
-    error: string;
     $id: string;
     $createdAt: string;
     $updatedAt: string;
-    collectionId: string;
     operationType: string;
+    collectionId: string;
+    data: any;
     progress: number;
     total: number;
-    data?: any;
+    error: string;
+    status: "error" | "pending" | "ready" | "in_progress" | "completed" | "cancelled";
     batches?: string[] | undefined;
 }>;
 export declare const updateOperation: (database: Databases, operationId: string, updateFields: any, useMigrations?: boolean) => Promise<void>;

package/dist/shared/operationQueue.js

@@ -1,7 +1,8 @@
 import { Query } from "node-appwrite";
-import { createOrUpdateAttribute } from "../collections/attributes.js";
+import { createOrUpdateAttributeWithStatusCheck } from "../collections/attributes.js";
 import { fetchAndCacheCollectionByName } from "../collections/methods.js";
 import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import chalk from "chalk";
 export const queuedOperations = [];
 export const nameToIdMapping = new Map();
 export const enqueueOperation = (operation) => {
@@ -55,14 +56,22 @@ export const processQueue = async (db, dbId) => {
             }
             // Process the operation if the collection is found
             if (collectionFound && operation.attribute) {
-                console.log(`\tProcessing attribute: ${operation.attribute.key} for collection ID: ${collectionFound.$id}`);
-                await createOrUpdateAttribute(db, dbId, collectionFound, operation.attribute);
-                queuedOperations.splice(i, 1);
-                i--; // Adjust index since we're modifying the array
-                progress = true;
+                console.log(chalk.cyan(`\t📋 Queue processing relationship attribute: ${operation.attribute.key} for collection: ${collectionFound.name}`));
+                const success = await createOrUpdateAttributeWithStatusCheck(db, dbId, collectionFound, operation.attribute);
+                if (success) {
+                    console.log(chalk.green(`\t✅ Successfully processed queued attribute: ${operation.attribute.key}`));
+                    queuedOperations.splice(i, 1);
+                    i--; // Adjust index since we're modifying the array
+                    progress = true;
+                }
+                else {
+                    console.log(chalk.red(`\t❌ Failed to process queued attribute: ${operation.attribute.key}, removing from queue`));
+                    queuedOperations.splice(i, 1);
+                    i--; // Adjust index since we're modifying the array
+                }
             }
             else {
-                console.error(`\tCollection not found for operation, removing from queue: ${JSON.stringify(operation)}`);
+                console.log(chalk.yellow(`\t⚠️ Collection not found for queued operation, removing from queue: ${operation.attribute?.key || 'unknown'}`));
                 queuedOperations.splice(i, 1);
                 i--; // Adjust index since we're modifying the array
             }

package/dist/shared/schemaGenerator.js

@@ -332,11 +332,6 @@ export default appwriteConfig;
     createSchemaString = (name, attributes) => {
         const pascalName = toPascalCase(name);
         let imports = `import { z } from "zod";\n`;
-        const hasDescription = attributes.some((attr) => attr.description);
-        if (hasDescription) {
-            imports += `import { extendZodWithOpenApi } from "@asteasolutions/zod-to-openapi";\n`;
-            imports += `extendZodWithOpenApi(z);\n`;
-        }
         // Use the relationshipMap to find related collections
         const relationshipDetails = this.relationshipMap.get(name) || [];
         const relatedCollections = relationshipDetails
@@ -461,7 +456,7 @@ export default appwriteConfig;
                 baseSchemaCode = "z.number().int()";
                 if (finalAttribute.min !== undefined) {
                     if (BigInt(finalAttribute.min) === BigInt(-9223372036854776000)) {
-                        delete finalAttribute.min;
+                        finalAttribute.min = undefined;
                     }
                     else {
                         baseSchemaCode += `.min(${finalAttribute.min}, "Minimum value of ${finalAttribute.min} not met")`;
@@ -469,7 +464,7 @@ export default appwriteConfig;
                 }
                 if (finalAttribute.max !== undefined) {
                     if (BigInt(finalAttribute.max) === BigInt(9223372036854776000)) {
-                        delete finalAttribute.max;
+                        finalAttribute.max = undefined;
                     }
                     else {
                         baseSchemaCode += `.max(${finalAttribute.max}, "Maximum value of ${finalAttribute.max} exceeded")`;
@@ -566,16 +561,6 @@ export default appwriteConfig;
         if (attribute.array && !attribute.required) {
             baseSchemaCode += ".nullish()";
         }
-        if (attribute.description) {
-            if (typeof attribute.description === "string") {
-                baseSchemaCode += `.openapi({ description: "${attribute.description}" })`;
-            }
-            else {
-                baseSchemaCode += `.openapi(${Object.entries(attribute.description)
-                    .map(([key, value]) => `"${key}": ${value}`)
-                    .join(", ")})`;
-            }
-        }
         return baseSchemaCode;
     };
 }