appwrite-utils-cli 0.10.86 → 1.0.2

package/src/shared/indexManager.ts

@@ -0,0 +1,253 @@
+import { type Index, type CollectionCreate } from "appwrite-utils";
+import { Databases, IndexType, Query, type Models } from "node-appwrite";
+import { delay, tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import chalk from "chalk";
+import pLimit from "p-limit";
+
+// Concurrency limits for different operations
+const indexLimit = pLimit(3);     // Low limit for index operations
+const queryLimit = pLimit(25);    // Higher limit for read operations
+
+export const indexesSame = (
+  databaseIndex: Models.Index,
+  configIndex: Index
+): boolean => {
+  return (
+    databaseIndex.key === configIndex.key &&
+    databaseIndex.type === configIndex.type &&
+    JSON.stringify(databaseIndex.attributes) === JSON.stringify(configIndex.attributes) &&
+    JSON.stringify(databaseIndex.orders) === JSON.stringify(configIndex.orders)
+  );
+};
+
+export const createOrUpdateIndex = async (
+  dbId: string,
+  db: Databases,
+  collectionId: string,
+  index: Index,
+  options: {
+    verbose?: boolean;
+    forceRecreate?: boolean;
+  } = {}
+): Promise<Models.Index | null> => {
+  const { verbose = false, forceRecreate = false } = options;
+
+  return await indexLimit(async () => {
+    // Check for existing index
+    const existingIndexes = await queryLimit(() =>
+      tryAwaitWithRetry(async () => 
+        await db.listIndexes(dbId, collectionId, [Query.equal("key", index.key)])
+      )
+    );
+
+    let shouldCreate = false;
+    let existingIndex: Models.Index | undefined;
+
+    if (existingIndexes.total > 0) {
+      existingIndex = existingIndexes.indexes[0];
+      
+      if (forceRecreate || !indexesSame(existingIndex, index)) {
+        if (verbose) {
+          console.log(chalk.yellow(`⚠ Updating index ${index.key} in collection ${collectionId}`));
+        }
+        
+        // Delete existing index
+        await tryAwaitWithRetry(async () => {
+          await db.deleteIndex(dbId, collectionId, existingIndex!.key);
+        });
+        
+        await delay(500); // Wait for deletion to complete
+        shouldCreate = true;
+      } else {
+        if (verbose) {
+          console.log(chalk.green(`✓ Index ${index.key} is up to date`));
+        }
+        return existingIndex;
+      }
+    } else {
+      shouldCreate = true;
+      if (verbose) {
+        console.log(chalk.blue(`+ Creating index ${index.key} in collection ${collectionId}`));
+      }
+    }
+
+    if (shouldCreate) {
+      const newIndex = await tryAwaitWithRetry(async () => {
+        return await db.createIndex(
+          dbId,
+          collectionId,
+          index.key,
+          index.type as IndexType,
+          index.attributes,
+          index.orders
+        );
+      });
+
+      if (verbose) {
+        console.log(chalk.green(`✓ Created index ${index.key}`));
+      }
+
+      return newIndex;
+    }
+
+    return null;
+  });
+};
+
+export const createOrUpdateIndexes = async (
+  dbId: string,
+  db: Databases,
+  collectionId: string,
+  indexes: Index[],
+  options: {
+    verbose?: boolean;
+    forceRecreate?: boolean;
+  } = {}
+): Promise<void> => {
+  const { verbose = false } = options;
+  
+  if (!indexes || indexes.length === 0) {
+    return;
+  }
+
+  if (verbose) {
+    console.log(chalk.blue(`Processing ${indexes.length} indexes for collection ${collectionId}`));
+  }
+
+  // Process indexes sequentially to avoid conflicts
+  for (const index of indexes) {
+    try {
+      await createOrUpdateIndex(dbId, db, collectionId, index, options);
+      
+      // Add delay between index operations to prevent rate limiting
+      await delay(250);
+    } catch (error) {
+      console.error(chalk.red(`❌ Failed to process index ${index.key}:`), error);
+      throw error;
+    }
+  }
+
+  if (verbose) {
+    console.log(chalk.green(`✓ Completed processing indexes for collection ${collectionId}`));
+  }
+};
+
+export const createUpdateCollectionIndexes = async (
+  db: Databases,
+  dbId: string,
+  collection: Models.Collection,
+  collectionConfig: CollectionCreate,
+  options: {
+    verbose?: boolean;
+    forceRecreate?: boolean;
+  } = {}
+): Promise<void> => {
+  if (!collectionConfig.indexes) return;
+
+  await createOrUpdateIndexes(
+    dbId,
+    db,
+    collection.$id,
+    collectionConfig.indexes,
+    options
+  );
+};
+
+export const deleteObsoleteIndexes = async (
+  db: Databases,
+  dbId: string,
+  collection: Models.Collection,
+  collectionConfig: CollectionCreate,
+  options: {
+    verbose?: boolean;
+  } = {}
+): Promise<void> => {
+  const { verbose = false } = options;
+
+  const configIndexes = collectionConfig.indexes || [];
+  const configIndexKeys = new Set(configIndexes.map(index => index.key));
+
+  // Get all existing indexes
+  const existingIndexes = await queryLimit(() =>
+    tryAwaitWithRetry(async () => 
+      await db.listIndexes(dbId, collection.$id)
+    )
+  );
+
+  // Find indexes that exist in the database but not in the config
+  const obsoleteIndexes = existingIndexes.indexes.filter(
+    (index) => !configIndexKeys.has(index.key)
+  );
+
+  if (obsoleteIndexes.length === 0) {
+    return;
+  }
+
+  if (verbose) {
+    console.log(chalk.yellow(`🗑️ Removing ${obsoleteIndexes.length} obsolete indexes from collection ${collection.name}`));
+  }
+
+  // Process deletions with rate limiting
+  for (const index of obsoleteIndexes) {
+    await indexLimit(async () => {
+      await tryAwaitWithRetry(async () => {
+        await db.deleteIndex(dbId, collection.$id, index.key);
+      });
+    });
+
+    if (verbose) {
+      console.log(chalk.gray(`🗑️ Deleted obsolete index ${index.key}`));
+    }
+
+    await delay(250);
+  }
+};
+
+export const validateIndexConfiguration = (
+  indexes: Index[],
+  options: {
+    verbose?: boolean;
+  } = {}
+): { valid: boolean; errors: string[] } => {
+  const { verbose = false } = options;
+  const errors: string[] = [];
+
+  for (const index of indexes) {
+    // Validate required fields
+    if (!index.key) {
+      errors.push(`Index missing required 'key' field`);
+    }
+
+    if (!index.type) {
+      errors.push(`Index '${index.key}' missing required 'type' field`);
+    }
+
+    if (!index.attributes || index.attributes.length === 0) {
+      errors.push(`Index '${index.key}' missing required 'attributes' field`);
+    }
+
+    // Validate index type
+    const validTypes = Object.values(IndexType);
+    if (index.type && !validTypes.includes(index.type as IndexType)) {
+      errors.push(`Index '${index.key}' has invalid type '${index.type}'. Valid types: ${validTypes.join(', ')}`);
+    }
+
+    // Validate orders array matches attributes length (if provided)
+    if (index.orders && index.attributes && index.orders.length !== index.attributes.length) {
+      errors.push(`Index '${index.key}' orders array length (${index.orders.length}) does not match attributes array length (${index.attributes.length})`);
+    }
+
+    // Check for duplicate keys within the same collection
+    const duplicateKeys = indexes.filter(i => i.key === index.key);
+    if (duplicateKeys.length > 1) {
+      errors.push(`Duplicate index key '${index.key}' found`);
+    }
+  }
+
+  if (verbose && errors.length > 0) {
+    console.log(chalk.red(`❌ Index validation errors:`));
+    errors.forEach(error => console.log(chalk.red(`  - ${error}`)));
+  }
+
+  return { valid: errors.length === 0, errors };
+};

package/src/shared/jsonSchemaGenerator.ts

@@ -0,0 +1,403 @@
+import fs from "fs";
+import path from "path";
+import type { AppwriteConfig, Attribute, CollectionCreate } from "appwrite-utils";
+import { toCamelCase, toPascalCase } from "../utils/index.js";
+import chalk from "chalk";
+
+export interface JsonSchemaProperty {
+  type: string | string[];
+  description?: string;
+  format?: string;
+  minimum?: number;
+  maximum?: number;
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+  enum?: any[];
+  items?: JsonSchemaProperty;
+  $ref?: string;
+  properties?: Record<string, JsonSchemaProperty>;
+  additionalProperties?: boolean;
+  required?: string[];
+  default?: any;
+  oneOf?: JsonSchemaProperty[];
+}
+
+export interface JsonSchema {
+  $schema: string;
+  $id: string;
+  title: string;
+  description?: string;
+  type: "object";
+  properties: Record<string, JsonSchemaProperty>;
+  required: string[];
+  additionalProperties: boolean;
+  definitions?: Record<string, JsonSchemaProperty>;
+}
+
+export class JsonSchemaGenerator {
+  private config: AppwriteConfig;
+  private appwriteFolderPath: string;
+  private relationshipMap = new Map<string, any[]>();
+
+  constructor(config: AppwriteConfig, appwriteFolderPath: string) {
+    this.config = config;
+    this.appwriteFolderPath = appwriteFolderPath;
+    this.extractRelationships();
+  }
+
+  private extractRelationships(): void {
+    if (!this.config.collections) return;
+
+    this.config.collections.forEach((collection) => {
+      if (!collection.attributes) return;
+
+      collection.attributes.forEach((attr) => {
+        if (attr.type === "relationship" && attr.relatedCollection) {
+          const relationships = this.relationshipMap.get(collection.name) || [];
+          relationships.push({
+            attributeKey: attr.key,
+            relatedCollection: attr.relatedCollection,
+            relationType: attr.relationType,
+            isArray: attr.relationType === "oneToMany" || attr.relationType === "manyToMany"
+          });
+          this.relationshipMap.set(collection.name, relationships);
+        }
+      });
+    });
+  }
+
+  private attributeToJsonSchemaProperty(attribute: Attribute): JsonSchemaProperty {
+    const property: JsonSchemaProperty = {
+      type: "string" // Default type
+    };
+
+    // Set description if available
+    if (attribute.description) {
+      property.description = typeof attribute.description === 'string' 
+        ? attribute.description 
+        : JSON.stringify(attribute.description);
+    }
+
+    // Handle array attributes
+    if (attribute.array) {
+      property.type = "array";
+      property.items = this.getBaseTypeSchema(attribute);
+    } else {
+      Object.assign(property, this.getBaseTypeSchema(attribute));
+    }
+
+    // Set default value (only for attributes that support it)
+    if (attribute.type !== "relationship" && "xdefault" in attribute && 
+        attribute.xdefault !== undefined && attribute.xdefault !== null) {
+      property.default = attribute.xdefault;
+    }
+
+    return property;
+  }
+
+  private getBaseTypeSchema(attribute: Attribute): JsonSchemaProperty {
+    const schema: JsonSchemaProperty = {
+      type: "string" // Default type
+    };
+
+    switch (attribute.type) {
+      case "string":
+        schema.type = "string";
+        if (attribute.size) {
+          schema.maxLength = attribute.size;
+        }
+        break;
+
+      case "integer":
+        schema.type = "integer";
+        if (attribute.min !== undefined) {
+          schema.minimum = Number(attribute.min);
+        }
+        if (attribute.max !== undefined) {
+          schema.maximum = Number(attribute.max);
+        }
+        break;
+
+      case "double":
+      case "float": // Backward compatibility
+        schema.type = "number";
+        if (attribute.min !== undefined) {
+          schema.minimum = Number(attribute.min);
+        }
+        if (attribute.max !== undefined) {
+          schema.maximum = Number(attribute.max);
+        }
+        break;
+
+      case "boolean":
+        schema.type = "boolean";
+        break;
+
+      case "datetime":
+        schema.type = "string";
+        schema.format = "date-time";
+        break;
+
+      case "email":
+        schema.type = "string";
+        schema.format = "email";
+        break;
+
+      case "ip":
+        schema.type = "string";
+        schema.format = "ipv4";
+        break;
+
+      case "url":
+        schema.type = "string";
+        schema.format = "uri";
+        break;
+
+      case "enum":
+        schema.type = "string";
+        if (attribute.elements) {
+          schema.enum = attribute.elements;
+        }
+        break;
+
+      case "relationship":
+        if (attribute.relatedCollection) {
+          // For relationships, reference the related collection schema
+          schema.$ref = `#/definitions/${toPascalCase(attribute.relatedCollection)}`;
+        } else {
+          schema.type = "string";
+          schema.description = "Document ID reference";
+        }
+        break;
+
+      default:
+        schema.type = "string";
+    }
+
+    return schema;
+  }
+
+  private createJsonSchema(collection: CollectionCreate): JsonSchema {
+    const pascalName = toPascalCase(collection.name);
+    const schema: JsonSchema = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: `https://example.com/schemas/${toCamelCase(collection.name)}.json`,
+      title: pascalName,
+      description: collection.description || `Schema for ${collection.name} collection`,
+      type: "object",
+      properties: {
+        // Standard Appwrite document fields
+        $id: {
+          type: "string",
+          description: "Document ID",
+          pattern: "^[a-zA-Z0-9][a-zA-Z0-9._-]{0,35}$"
+        },
+        $createdAt: {
+          type: "string",
+          format: "date-time",
+          description: "Document creation date"
+        },
+        $updatedAt: {
+          type: "string", 
+          format: "date-time",
+          description: "Document last update date"
+        },
+        $permissions: {
+          type: "array",
+          items: {
+            type: "string"
+          },
+          description: "Document permissions"
+        }
+      },
+      required: ["$id", "$createdAt", "$updatedAt"],
+      additionalProperties: false
+    };
+
+    // Add custom attributes
+    const requiredFields: string[] = [...schema.required];
+    
+    if (collection.attributes) {
+      collection.attributes.forEach((attribute) => {
+        schema.properties[attribute.key] = this.attributeToJsonSchemaProperty(attribute);
+        
+        if (attribute.required) {
+          requiredFields.push(attribute.key);
+        }
+      });
+    }
+
+    schema.required = requiredFields;
+
+    // Add relationship definitions if any exist
+    const relationships = this.relationshipMap.get(collection.name);
+    if (relationships && relationships.length > 0) {
+      schema.definitions = {};
+      
+      relationships.forEach((rel) => {
+        const relatedPascalName = toPascalCase(rel.relatedCollection);
+        schema.definitions![relatedPascalName] = {
+          type: "object",
+          properties: {
+            $id: { type: "string" },
+            $createdAt: { type: "string", format: "date-time" },
+            $updatedAt: { type: "string", format: "date-time" }
+          },
+          additionalProperties: true,
+          description: `Reference to ${rel.relatedCollection} document`
+        };
+      });
+    }
+
+    return schema;
+  }
+
+  public generateJsonSchemas(options: {
+    outputFormat?: "json" | "typescript" | "both";
+    outputDirectory?: string;
+    verbose?: boolean;
+  } = {}): void {
+    const { outputFormat = "both", outputDirectory = "schemas", verbose = false } = options;
+
+    if (!this.config.collections) {
+      if (verbose) {
+        console.log(chalk.yellow("No collections found in config"));
+      }
+      return;
+    }
+
+    // Create JSON schemas directory using provided outputDirectory
+    const jsonSchemasPath = path.join(this.appwriteFolderPath, outputDirectory);
+    if (!fs.existsSync(jsonSchemasPath)) {
+      fs.mkdirSync(jsonSchemasPath, { recursive: true });
+    }
+
+    if (verbose) {
+      console.log(chalk.blue(`Generating JSON schemas for ${this.config.collections.length} collections...`));
+    }
+
+    this.config.collections.forEach((collection) => {
+      const schema = this.createJsonSchema(collection);
+      const camelCaseName = toCamelCase(collection.name);
+
+      // Generate JSON file
+      if (outputFormat === "json" || outputFormat === "both") {
+        const jsonPath = path.join(jsonSchemasPath, `${camelCaseName}.json`);
+        fs.writeFileSync(jsonPath, JSON.stringify(schema, null, 2), { encoding: "utf-8" });
+        
+        if (verbose) {
+          console.log(chalk.green(`✓ JSON schema written to ${jsonPath}`));
+        }
+      }
+
+      // Generate TypeScript file
+      if (outputFormat === "typescript" || outputFormat === "both") {
+        const tsContent = this.generateTypeScriptSchema(schema, collection.name);
+        const tsPath = path.join(jsonSchemasPath, `${camelCaseName}.schema.ts`);
+        fs.writeFileSync(tsPath, tsContent, { encoding: "utf-8" });
+        
+        if (verbose) {
+          console.log(chalk.green(`✓ TypeScript schema written to ${tsPath}`));
+        }
+      }
+    });
+
+    // Generate index file only for TypeScript output
+    if (outputFormat === "typescript" || outputFormat === "both") {
+      this.generateIndexFile(outputFormat, jsonSchemasPath, verbose);
+    }
+
+    if (verbose) {
+      console.log(chalk.green("✓ JSON schema generation completed"));
+    }
+  }
+
+  private generateTypeScriptSchema(schema: JsonSchema, collectionName: string): string {
+    const camelName = toCamelCase(collectionName);
+
+    return `// Auto-generated JSON schema for ${collectionName}
+import type { JSONSchema7 } from "json-schema";
+
+export const ${camelName}JsonSchema: JSONSchema7 = ${JSON.stringify(schema, null, 2)} as const;
+
+export type ${toPascalCase(collectionName)}JsonSchema = typeof ${camelName}JsonSchema;
+
+export default ${camelName}JsonSchema;
+`;
+  }
+
+  private generateIndexFile(outputFormat: string, jsonSchemasPath: string, verbose: boolean): void {
+    if (!this.config.collections) return;
+
+    const indexPath = path.join(jsonSchemasPath, "index.ts");
+
+    const imports: string[] = [];
+    const exports: string[] = [];
+
+    this.config.collections.forEach((collection) => {
+      const camelName = toCamelCase(collection.name);
+      const pascalName = toPascalCase(collection.name);
+
+      if (outputFormat === "typescript" || outputFormat === "both") {
+        imports.push(`import { ${camelName}JsonSchema } from "./${camelName}.schema.js";`);
+        exports.push(`  ${camelName}: ${camelName}JsonSchema,`);
+      }
+    });
+
+    const indexContent = `// Auto-generated index for JSON schemas
+${imports.join('\n')}
+
+export const jsonSchemas = {
+${exports.join('\n')}
+};
+
+export type JsonSchemas = typeof jsonSchemas;
+
+// Individual schema exports
+${this.config.collections.map(collection => {
+  const camelName = toCamelCase(collection.name);
+  return `export { ${camelName}JsonSchema } from "./${camelName}.schema.js";`;
+}).join('\n')}
+
+export default jsonSchemas;
+`;
+
+    fs.writeFileSync(indexPath, indexContent, { encoding: "utf-8" });
+
+    if (verbose) {
+      console.log(chalk.green(`✓ Index file written to ${indexPath}`));
+    }
+  }
+
+  public validateSchema(schema: JsonSchema): { valid: boolean; errors: string[] } {
+    const errors: string[] = [];
+
+    // Basic validation
+    if (!schema.$schema) {
+      errors.push("Missing $schema property");
+    }
+
+    if (!schema.title) {
+      errors.push("Missing title property");
+    }
+
+    if (!schema.properties) {
+      errors.push("Missing properties");
+    }
+
+    if (!schema.required || !Array.isArray(schema.required)) {
+      errors.push("Missing or invalid required array");
+    }
+
+    // Validate required Appwrite fields
+    const requiredAppwriteFields = ["$id", "$createdAt", "$updatedAt"];
+    requiredAppwriteFields.forEach((field) => {
+      if (!schema.properties[field]) {
+        errors.push(`Missing required Appwrite field: ${field}`);
+      }
+    });
+
+    return { valid: errors.length === 0, errors };
+  }
+}