appwrite-utils-cli 0.0.286 → 0.9.2

package/src/migrations/openapi.ts

@@ -1,70 +1,83 @@
-import {
-  OpenAPIRegistry,
-  OpenApiGeneratorV3,
-  OpenApiGeneratorV31,
-} from "@asteasolutions/zod-to-openapi";
-import {
-  attributeSchema,
-  CollectionSchema,
-  type AppwriteConfig,
-  type Attribute,
-  type Collection,
-  type CollectionCreate,
-} from "appwrite-utils";
-import { z } from "zod";
-import { writeFileSync } from "fs";
-
-const registry = new OpenAPIRegistry();
-
-export const generateOpenApi = async (config: AppwriteConfig) => {
-  if (!config.collections) {
-    return;
-  }
-  for (const collection of config.collections) {
-    // Transform and register each attribute schema
-    const attributeSchemas = collection.attributes.map((attribute) => {
-      return transformTypeToOpenApi(attributeSchema);
-    });
-
-    // Create and register the collection schema with descriptions
-    const updatedCollectionSchema = CollectionSchema.extend({
-      // @ts-ignore
-      attributes: z.array(z.union(attributeSchemas)),
-    }).openapi(collection.description ?? "No description");
-
-    // Register the updated collection schema under the collection name
-    registry.register(collection.name, updatedCollectionSchema);
-  }
-
-  // Convert the registry to OpenAPI JSON
-  // @ts-ignore
-  const openApiSpec = registry.toOpenAPI();
-
-  // Output the OpenAPI spec to a file
-  writeFileSync(
-    "./appwrite/openapi/openapi.json",
-    JSON.stringify(openApiSpec, null, 2)
-  );
-};
-
-export function transformTypeToOpenApi<T extends z.ZodTypeAny>(
-  schema: T
-): z.infer<T> {
-  return schema.transform((data) => {
-    let finalData = data;
-    if (data._def.attributes) {
-      finalData._def.attributes = data._def.attributes.map(
-        (attribute: typeof attributeSchema) => {
-          if (attribute.description) {
-            return attribute.openapi(attribute.description);
-          }
-          return attribute;
-        }
-      );
-    }
-    if (schema.description) {
-      finalData.openapi(schema.description);
-    }
-    return finalData;
-  });
-}
+import {
+  OpenAPIRegistry,
+  OpenApiGeneratorV3,
+  OpenApiGeneratorV31,
+} from "@asteasolutions/zod-to-openapi";
+import {
+  attributeSchema,
+  CollectionSchema,
+  type AppwriteConfig,
+  type Attribute,
+  type Collection,
+  type CollectionCreate,
+} from "appwrite-utils";
+import { z } from "zod";
+import { writeFileSync } from "fs";
+
+const registry = new OpenAPIRegistry();
+
+export const generateOpenApi = async (config: AppwriteConfig) => {
+  if (!config.collections) {
+    return;
+  }
+  for (const collection of config.collections) {
+    // Transform and register each attribute schema
+    const attributeSchemas = collection.attributes.map((attribute) => {
+      return transformTypeToOpenApi(attributeSchema, attribute.description);
+    });
+
+    // Create and register the collection schema with descriptions
+    const updatedCollectionSchema = CollectionSchema.extend({
+      // @ts-ignore
+      attributes: attributeSchemas,
+    }).openapi(collection.description ?? "No description");
+
+    // Register the updated collection schema under the collection name
+    registry.register(collection.name, updatedCollectionSchema);
+  }
+
+  // Convert the registry to OpenAPI JSON
+  const generator = new OpenApiGeneratorV31(registry.definitions);
+  const openApiSpec = generator.generateComponents();
+
+  // Output the OpenAPI spec to a file
+  writeFileSync(
+    "./appwrite/openapi/openapi.json",
+    JSON.stringify(openApiSpec, null, 2)
+  );
+};
+
+export function transformTypeToOpenApi<T extends z.ZodTypeAny>(
+  schema: T,
+  description?: string | Record<string, any> | null | undefined
+): T {
+  // Check if description is an object (OpenAPI properties) or a string
+  let updatedSchema: z.infer<T>;
+  if (!description) {
+    return schema;
+  }
+  if (typeof description === "string") {
+    updatedSchema = schema.openapi(description);
+  } else if (typeof description === "object") {
+    updatedSchema = schema.openapi(description);
+  } else {
+    updatedSchema = schema;
+  }
+
+  // Check and transform attributes if they exist
+  if ((schema as any)._def && (schema as any)._def.shape) {
+    const shape = (schema as any)._def.shape();
+    for (const key in shape) {
+      const attributeDesc = shape[key].description;
+      if (attributeDesc) {
+        if (typeof attributeDesc === "string") {
+          shape[key] = shape[key].openapi(attributeDesc);
+        } else if (typeof attributeDesc === "object") {
+          shape[key] = shape[key].openapi(attributeDesc);
+        }
+      }
+    }
+  }
+
+  return updatedSchema;
+}

package/src/migrations/queue.ts

@@ -1,119 +1,118 @@
-import { Query, type Databases, type Models } from "node-appwrite";
-import type { Attribute } from "appwrite-utils";
-import { createOrUpdateAttribute } from "./attributes.js";
-import _ from "lodash";
-import { fetchAndCacheCollectionByName } from "./collections.js";
-
-export interface QueuedOperation {
-  type: "attribute";
-  collectionId?: string;
-  attribute?: Attribute;
-  collection?: Models.Collection;
-  dependencies?: string[];
-}
-export const queuedOperations: QueuedOperation[] = [];
-export const nameToIdMapping: Map<string, string> = new Map();
-
-export const enqueueOperation = (operation: QueuedOperation) => {
-  queuedOperations.push(operation);
-};
-
-export const processQueue = async (db: Databases, dbId: string) => {
-  console.log("---------------------------------");
-  console.log(`Starting Queue processing of ${dbId}`);
-  console.log("---------------------------------");
-  let progress = true;
-
-  while (progress) {
-    progress = false;
-    console.log("Processing queued operations:");
-    for (let i = 0; i < queuedOperations.length; i++) {
-      const operation = queuedOperations[i];
-      let collectionFound: Models.Collection | undefined;
-
-      // Handle relationship attribute operations
-      if (operation.attribute?.type === "relationship") {
-        // Attempt to resolve the collection directly if collectionId is specified
-        if (operation.collectionId) {
-          console.log(`\tFetching collection by ID: ${operation.collectionId}`);
-          try {
-            collectionFound = await db.getCollection(
-              dbId,
-              operation.collectionId
-            );
-          } catch (e) {
-            console.log(
-              `\tCollection not found by ID: ${operation.collectionId}`
-            );
-          }
-        }
-        // Attempt to resolve related collection if specified and not already found
-        if (!collectionFound && operation.attribute?.relatedCollection) {
-          collectionFound = await fetchAndCacheCollectionByName(
-            db,
-            dbId,
-            operation.attribute.relatedCollection
-          );
-        }
-        // Handle dependencies if collection still not found
-        if (!collectionFound) {
-          for (const dep of operation.dependencies || []) {
-            collectionFound = await fetchAndCacheCollectionByName(
-              db,
-              dbId,
-              dep
-            );
-            if (collectionFound) break; // Break early if collection is found
-          }
-        }
-      } else if (operation.collectionId) {
-        // Handle non-relationship operations with a specified collectionId
-        console.log(`\tFetching collection by ID: ${operation.collectionId}`);
-        try {
-          collectionFound = await db.getCollection(
-            dbId,
-            operation.collectionId
-          );
-        } catch (e) {
-          console.log(
-            `\tCollection not found by ID: ${operation.collectionId}`
-          );
-        }
-      }
-
-      // 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;
-      } else {
-        console.error(
-          `\tCollection not found for operation, removing from queue: ${JSON.stringify(
-            operation
-          )}`
-        );
-        queuedOperations.splice(i, 1);
-        i--; // Adjust index since we're modifying the array
-      }
-    }
-    console.log(`\tFinished processing queued operations`);
-  }
-
-  if (queuedOperations.length > 0) {
-    console.error("Unresolved operations remain due to unmet dependencies.");
-    console.log(queuedOperations);
-  }
-
-  console.log("---------------------------------");
-  console.log(`Queue processing complete for ${dbId}`);
-  console.log("---------------------------------");
-};
+import { Query, type Databases, type Models } from "node-appwrite";
+import type { Attribute } from "appwrite-utils";
+import { createOrUpdateAttribute } from "./attributes.js";
+import _ from "lodash";
+import { fetchAndCacheCollectionByName } from "./collections.js";
+import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
+
+export interface QueuedOperation {
+  type: "attribute";
+  collectionId?: string;
+  attribute?: Attribute;
+  collection?: Models.Collection;
+  dependencies?: string[];
+}
+export const queuedOperations: QueuedOperation[] = [];
+export const nameToIdMapping: Map<string, string> = new Map();
+
+export const enqueueOperation = (operation: QueuedOperation) => {
+  queuedOperations.push(operation);
+};
+
+export const processQueue = async (db: Databases, dbId: string) => {
+  console.log("---------------------------------");
+  console.log(`Starting Queue processing of ${dbId}`);
+  console.log("---------------------------------");
+  let progress = true;
+
+  while (progress) {
+    progress = false;
+    console.log("Processing queued operations:");
+    for (let i = 0; i < queuedOperations.length; i++) {
+      const operation = queuedOperations[i];
+      let collectionFound: Models.Collection | undefined;
+
+      // Handle relationship attribute operations
+      if (operation.attribute?.type === "relationship") {
+        // Attempt to resolve the collection directly if collectionId is specified
+        if (operation.collectionId) {
+          console.log(`\tFetching collection by ID: ${operation.collectionId}`);
+          try {
+            collectionFound = await tryAwaitWithRetry(
+              async () => await db.getCollection(dbId, operation.collectionId!)
+            );
+          } catch (e) {
+            console.log(
+              `\tCollection not found by ID: ${operation.collectionId}`
+            );
+          }
+        }
+        // Attempt to resolve related collection if specified and not already found
+        if (!collectionFound && operation.attribute?.relatedCollection) {
+          collectionFound = await fetchAndCacheCollectionByName(
+            db,
+            dbId,
+            operation.attribute.relatedCollection
+          );
+        }
+        // Handle dependencies if collection still not found
+        if (!collectionFound) {
+          for (const dep of operation.dependencies || []) {
+            collectionFound = await fetchAndCacheCollectionByName(
+              db,
+              dbId,
+              dep
+            );
+            if (collectionFound) break; // Break early if collection is found
+          }
+        }
+      } else if (operation.collectionId) {
+        // Handle non-relationship operations with a specified collectionId
+        console.log(`\tFetching collection by ID: ${operation.collectionId}`);
+        try {
+          collectionFound = await tryAwaitWithRetry(
+            async () => await db.getCollection(dbId, operation.collectionId!)
+          );
+        } catch (e) {
+          console.log(
+            `\tCollection not found by ID: ${operation.collectionId}`
+          );
+        }
+      }
+
+      // 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;
+      } else {
+        console.error(
+          `\tCollection not found for operation, removing from queue: ${JSON.stringify(
+            operation
+          )}`
+        );
+        queuedOperations.splice(i, 1);
+        i--; // Adjust index since we're modifying the array
+      }
+    }
+    console.log(`\tFinished processing queued operations`);
+  }
+
+  if (queuedOperations.length > 0) {
+    console.error("Unresolved operations remain due to unmet dependencies.");
+    console.log(queuedOperations);
+  }
+
+  console.log("---------------------------------");
+  console.log(`Queue processing complete for ${dbId}`);
+  console.log("---------------------------------");
+};