appwrite-utils-cli 1.9.7 → 1.11.0

package/dist/shared/functionManager.js

@@ -1,348 +0,0 @@
-import { Client, Functions, Runtime } from "node-appwrite";
-import { EventTypeSchema } from "appwrite-utils";
-import { join, relative, resolve, basename } from "node:path";
-import fs from "node:fs";
-import chalk from "chalk";
-import pLimit from "p-limit";
-import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
-import { MessageFormatter } from "./messageFormatter.js";
-/**
- * Validates and filters events array for Appwrite functions
- * - Filters out empty/invalid strings
- * - Validates against EventTypeSchema
- * - Limits to 100 items maximum (Appwrite limit)
- * - Returns empty array if input is invalid
- */
-const validateEvents = (events) => {
-    if (!events || !Array.isArray(events))
-        return [];
-    return events
-        .filter(event => {
-        if (!event || typeof event !== 'string' || event.trim().length === 0) {
-            return false;
-        }
-        // Validate against EventTypeSchema
-        const result = EventTypeSchema.safeParse(event);
-        if (!result.success) {
-            MessageFormatter.warning(`Invalid event type "${event}" will be filtered out`, { prefix: "Functions" });
-            return false;
-        }
-        return true;
-    })
-        .slice(0, 100);
-};
-// Concurrency limits
-const functionLimit = pLimit(5); // Moderate limit for function operations
-const queryLimit = pLimit(25); // Higher limit for read operations
-export class FunctionManager {
-    client;
-    functions;
-    constructor(client) {
-        this.client = client;
-        this.functions = new Functions(client);
-    }
-    /**
-     * Improved function directory detection with multiple strategies
-     */
-    async findFunctionDirectory(functionName, options = {}) {
-        const { searchPaths = [process.cwd()], caseSensitive = false, allowFuzzyMatch = true, verbose = false } = options;
-        if (verbose) {
-            MessageFormatter.info(`Searching for function: ${functionName}`, { prefix: "Functions" });
-        }
-        // Normalize function name for comparison
-        const normalizedName = caseSensitive ? functionName : functionName.toLowerCase();
-        const nameVariations = this.generateNameVariations(normalizedName);
-        // Strategy 1: Check standard locations first
-        const standardPaths = this.getStandardFunctionPaths(searchPaths, functionName);
-        for (const path of standardPaths) {
-            if (await this.isValidFunctionDirectory(path)) {
-                if (verbose) {
-                    MessageFormatter.success(`Found function at standard location: ${path}`, { prefix: "Functions" });
-                }
-                return path;
-            }
-        }
-        // Strategy 2: Recursive directory search with fuzzy matching
-        if (allowFuzzyMatch) {
-            for (const searchPath of searchPaths) {
-                const foundPath = await this.recursiveDirectorySearch(searchPath, nameVariations, { caseSensitive, verbose });
-                if (foundPath) {
-                    if (verbose) {
-                        MessageFormatter.success(`Found function via fuzzy search: ${foundPath}`, { prefix: "Functions" });
-                    }
-                    return foundPath;
-                }
-            }
-        }
-        if (verbose) {
-            MessageFormatter.warning(`Function directory not found: ${functionName}`, { prefix: "Functions" });
-        }
-        return null;
-    }
-    generateNameVariations(name) {
-        const variations = new Set([
-            name,
-            name.toLowerCase(),
-            name.replace(/\s+/g, "-"),
-            name.replace(/\s+/g, "_"),
-            name.replace(/[^a-z0-9]/gi, ""),
-            name.replace(/[-_\s]+/g, ""),
-            name.replace(/[-_\s]+/g, "-").toLowerCase(),
-            name.replace(/[-_\s]+/g, "_").toLowerCase(),
-        ]);
-        return variations;
-    }
-    getStandardFunctionPaths(searchPaths, functionName) {
-        const normalizedName = functionName.toLowerCase().replace(/\s+/g, "-");
-        const paths = [];
-        for (const basePath of searchPaths) {
-            paths.push(join(basePath, "functions", functionName), join(basePath, "functions", normalizedName), join(basePath, "src", "functions", functionName), join(basePath, "src", "functions", normalizedName), join(basePath, functionName), join(basePath, normalizedName), join(basePath, "appwrite", "functions", functionName), join(basePath, "appwrite", "functions", normalizedName));
-        }
-        return paths;
-    }
-    async recursiveDirectorySearch(searchPath, nameVariations, options) {
-        const { caseSensitive, verbose } = options;
-        try {
-            const stats = await fs.promises.stat(searchPath);
-            if (!stats.isDirectory())
-                return null;
-            const entries = await fs.promises.readdir(searchPath, { withFileTypes: true });
-            for (const entry of entries) {
-                if (!entry.isDirectory())
-                    continue;
-                // Skip common directories that won't contain functions
-                if (this.shouldSkipDirectory(entry.name))
-                    continue;
-                const entryPath = join(searchPath, entry.name);
-                // Check if this directory matches our function name
-                const entryNameToCheck = caseSensitive ? entry.name : entry.name.toLowerCase();
-                if (nameVariations.has(entryNameToCheck)) {
-                    if (await this.isValidFunctionDirectory(entryPath)) {
-                        return entryPath;
-                    }
-                }
-                // Recursively search subdirectories
-                const result = await this.recursiveDirectorySearch(entryPath, nameVariations, options);
-                if (result)
-                    return result;
-            }
-        }
-        catch (error) {
-            if (verbose) {
-                MessageFormatter.debug(`Skipping inaccessible directory: ${searchPath}`, undefined, { prefix: "Functions" });
-            }
-        }
-        return null;
-    }
-    shouldSkipDirectory(dirName) {
-        const skipDirs = new Set([
-            'node_modules',
-            '.git',
-            '.vscode',
-            '.idea',
-            'dist',
-            'build',
-            'coverage',
-            '.nyc_output',
-            'tmp',
-            'temp',
-            '.cache',
-            '__pycache__',
-            '.pytest_cache',
-            'venv',
-            '.venv',
-            'env',
-            '.env'
-        ]);
-        return skipDirs.has(dirName) || dirName.startsWith('.');
-    }
-    async isValidFunctionDirectory(path) {
-        try {
-            const stats = await fs.promises.stat(path);
-            if (!stats.isDirectory())
-                return false;
-            const files = await fs.promises.readdir(path);
-            // Check for common function indicators
-            const hasPackageJson = files.includes('package.json');
-            const hasMainFile = files.some(file => file.match(/^(index|main|app)\.(js|ts|py)$/i) ||
-                file === 'src' ||
-                file === 'lib');
-            const hasRequirements = files.includes('requirements.txt');
-            const hasPyProject = files.includes('pyproject.toml');
-            return hasPackageJson || hasMainFile || hasRequirements || hasPyProject;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Enhanced function deployment with better error handling and validation
-     */
-    async deployFunction(functionConfig, functionPath, options = {}) {
-        const { activate = true, entrypoint = functionConfig.entrypoint || "index.js", commands = functionConfig.commands || "npm install", ignored = ["node_modules", ".git", ".vscode", ".DS_Store", "__pycache__", ".venv"], verbose = false, forceRedeploy = false } = options;
-        return await functionLimit(async () => {
-            if (verbose) {
-                MessageFormatter.processing(`Deploying function: ${functionConfig.name}`, { prefix: "Functions" });
-                MessageFormatter.debug(`Path: ${functionPath}`, undefined, { prefix: "Functions" });
-                MessageFormatter.debug(`Entrypoint: ${entrypoint}`, undefined, { prefix: "Functions" });
-            }
-            // Validate function directory
-            if (!await this.isValidFunctionDirectory(functionPath)) {
-                throw new Error(`Invalid function directory: ${functionPath}`);
-            }
-            // Ensure function exists
-            let functionExists = false;
-            try {
-                await this.getFunction(functionConfig.$id);
-                functionExists = true;
-            }
-            catch (error) {
-                if (verbose) {
-                    MessageFormatter.info(`Function ${functionConfig.$id} does not exist, creating...`, { prefix: "Functions" });
-                }
-            }
-            // Create function if it doesn't exist
-            if (!functionExists) {
-                await this.createFunction(functionConfig, { verbose });
-            }
-            else if (forceRedeploy) {
-                await this.updateFunction(functionConfig, { verbose });
-            }
-            // Execute pre-deploy commands if specified
-            if (functionConfig.predeployCommands?.length) {
-                await this.executePredeployCommands(functionConfig.predeployCommands, functionPath, { verbose });
-            }
-            // Deploy the function
-            const deployment = await this.createDeployment(functionConfig.$id, functionPath, { activate, entrypoint, commands, ignored, verbose });
-            if (verbose) {
-                MessageFormatter.success(`Function ${functionConfig.name} deployed successfully`, { prefix: "Functions" });
-            }
-            return deployment;
-        });
-    }
-    async createFunction(functionConfig, options = {}) {
-        const { verbose = false } = options;
-        if (verbose) {
-            MessageFormatter.processing(`Creating function: ${functionConfig.name}`, { prefix: "Functions" });
-        }
-        return await tryAwaitWithRetry(async () => {
-            return await this.functions.create(functionConfig.$id, functionConfig.name, functionConfig.runtime, functionConfig.execute || [], functionConfig.events || [], functionConfig.schedule || "", functionConfig.timeout || 15, functionConfig.enabled !== false, functionConfig.logging !== false, functionConfig.entrypoint, functionConfig.commands, functionConfig.scopes || [], functionConfig.installationId, functionConfig.providerRepositoryId, functionConfig.providerBranch, functionConfig.providerSilentMode, functionConfig.providerRootDirectory);
-        });
-    }
-    async updateFunction(functionConfig, options = {}) {
-        const { verbose = false } = options;
-        if (verbose) {
-            MessageFormatter.processing(`Updating function: ${functionConfig.name}`, { prefix: "Functions" });
-        }
-        return await tryAwaitWithRetry(async () => {
-            return await this.functions.update(functionConfig.$id, functionConfig.name, functionConfig.runtime, functionConfig.execute || [], functionConfig.events || [], functionConfig.schedule || "", functionConfig.timeout || 15, functionConfig.enabled !== false, functionConfig.logging !== false, functionConfig.entrypoint, functionConfig.commands, functionConfig.scopes || [], functionConfig.installationId, functionConfig.providerRepositoryId, functionConfig.providerBranch, functionConfig.providerSilentMode, functionConfig.providerRootDirectory, functionConfig.specification);
-        });
-    }
-    async executePredeployCommands(commands, workingDir, options = {}) {
-        const { verbose = false } = options;
-        const { execSync } = await import("child_process");
-        const { platform } = await import("node:os");
-        if (verbose) {
-            MessageFormatter.processing("Executing pre-deploy commands...", { prefix: "Functions" });
-        }
-        const isWindows = platform() === "win32";
-        for (const command of commands) {
-            if (verbose) {
-                MessageFormatter.debug(`$ ${command}`, undefined, { prefix: "Functions" });
-            }
-            try {
-                execSync(command, {
-                    cwd: workingDir,
-                    stdio: verbose ? "inherit" : "pipe",
-                    shell: isWindows ? "cmd.exe" : "/bin/sh",
-                    windowsHide: true,
-                });
-            }
-            catch (error) {
-                MessageFormatter.error(`Failed to execute command: ${command}`, error, { prefix: "Functions" });
-                throw error;
-            }
-        }
-        if (verbose) {
-            MessageFormatter.success("Pre-deploy commands completed", { prefix: "Functions" });
-        }
-    }
-    async createDeployment(functionId, codePath, options = {}) {
-        const { activate = true, entrypoint = "index.js", commands = "npm install", ignored = [], verbose = false } = options;
-        const { InputFile } = await import("node-appwrite/file");
-        const { create: createTarball } = await import("tar");
-        const tarPath = join(process.cwd(), `function-${functionId}-${Date.now()}.tar.gz`);
-        try {
-            if (verbose) {
-                MessageFormatter.processing("Creating deployment archive...", { prefix: "Functions" });
-            }
-            // Create tarball
-            await createTarball({
-                gzip: true,
-                file: tarPath,
-                cwd: codePath,
-                filter: (path) => {
-                    const relativePath = relative(codePath, join(codePath, path)).toLowerCase();
-                    const shouldIgnore = ignored.some(pattern => relativePath.startsWith(pattern.toLowerCase()) ||
-                        relativePath.includes(`/${pattern.toLowerCase()}`) ||
-                        relativePath.includes(`\\${pattern.toLowerCase()}`));
-                    if (shouldIgnore && verbose) {
-                        MessageFormatter.debug(`Ignoring: ${path}`, undefined, { prefix: "Functions" });
-                    }
-                    return !shouldIgnore;
-                },
-            }, ["."]);
-            // Read and upload
-            const fileBuffer = await fs.promises.readFile(tarPath);
-            const fileObject = InputFile.fromBuffer(new Uint8Array(fileBuffer), `function-${functionId}.tar.gz`);
-            if (verbose) {
-                MessageFormatter.processing("Uploading deployment...", { prefix: "Functions" });
-            }
-            const deployment = await tryAwaitWithRetry(async () => {
-                return await this.functions.createDeployment(functionId, fileObject, activate, entrypoint, commands);
-            });
-            return deployment;
-        }
-        finally {
-            // Clean up tarball
-            try {
-                await fs.promises.unlink(tarPath);
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        }
-    }
-    async getFunction(functionId) {
-        return await queryLimit(() => tryAwaitWithRetry(async () => await this.functions.get(functionId)));
-    }
-    async listFunctions() {
-        return await queryLimit(() => tryAwaitWithRetry(async () => await this.functions.list()));
-    }
-    async deleteFunction(functionId) {
-        await functionLimit(() => tryAwaitWithRetry(async () => await this.functions.delete(functionId)));
-    }
-    /**
-     * Validate function configuration
-     */
-    validateFunctionConfig(functionConfig) {
-        const errors = [];
-        if (!functionConfig.$id) {
-            errors.push("Function ID is required");
-        }
-        if (!functionConfig.name) {
-            errors.push("Function name is required");
-        }
-        if (!functionConfig.runtime) {
-            errors.push("Function runtime is required");
-        }
-        if (!functionConfig.entrypoint) {
-            errors.push("Function entrypoint is required");
-        }
-        // Validate timeout
-        if (functionConfig.timeout && (functionConfig.timeout < 1 || functionConfig.timeout > 900)) {
-            errors.push("Function timeout must be between 1 and 900 seconds");
-        }
-        return { valid: errors.length === 0, errors };
-    }
-}

package/dist/shared/jsonSchemaGenerator.d.ts

@@ -1,50 +0,0 @@
-import type { AppwriteConfig } from "appwrite-utils";
-export interface JsonSchemaProperty {
-    type: string | 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;
-    type: "object";
-    properties: Record<string, JsonSchemaProperty>;
-    required: string[];
-    additionalProperties: boolean;
-    definitions?: Record<string, JsonSchemaProperty>;
-}
-export declare class JsonSchemaGenerator {
-    private config;
-    private appwriteFolderPath;
-    private relationshipMap;
-    constructor(config: AppwriteConfig, appwriteFolderPath: string);
-    private resolveCollectionName;
-    private extractRelationships;
-    private attributeToJsonSchemaProperty;
-    private getBaseTypeSchema;
-    private createJsonSchema;
-    generateJsonSchemas(options?: {
-        outputFormat?: "json" | "typescript" | "both";
-        outputDirectory?: string;
-        verbose?: boolean;
-    }): void;
-    private generateTypeScriptSchema;
-    private generateIndexFile;
-    validateSchema(schema: JsonSchema): {
-        valid: boolean;
-        errors: string[];
-    };
-}

package/dist/shared/jsonSchemaGenerator.js

@@ -1,290 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { toCamelCase, toPascalCase } from "../utils/index.js";
-import chalk from "chalk";
-import { extractSimpleRelationships, resolveCollectionName } from "./relationshipExtractor.js";
-import { MessageFormatter } from "./messageFormatter.js";
-export class JsonSchemaGenerator {
-    config;
-    appwriteFolderPath;
-    relationshipMap = new Map();
-    constructor(config, appwriteFolderPath) {
-        this.config = config;
-        this.appwriteFolderPath = appwriteFolderPath;
-        this.extractRelationships();
-    }
-    resolveCollectionName = (idOrName) => {
-        return resolveCollectionName(this.config, idOrName);
-    };
-    extractRelationships() {
-        this.relationshipMap = extractSimpleRelationships(this.config);
-    }
-    attributeToJsonSchemaProperty(attribute) {
-        const property = {
-            type: "string" // Default type
-        };
-        // 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;
-    }
-    getBaseTypeSchema(attribute) {
-        const schema = {
-            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(this.resolveCollectionName(attribute.relatedCollection))}`;
-                }
-                else {
-                    schema.type = "string";
-                }
-                break;
-            default:
-                schema.type = "string";
-        }
-        return schema;
-    }
-    createJsonSchema(collection) {
-        const pascalName = toPascalCase(collection.name);
-        const schema = {
-            $schema: "https://json-schema.org/draft/2020-12/schema",
-            $id: `https://example.com/schemas/${toCamelCase(collection.name)}.json`,
-            title: pascalName,
-            type: "object",
-            properties: {
-                // Standard Appwrite document fields
-                $id: {
-                    type: "string",
-                    pattern: "^[a-zA-Z0-9][a-zA-Z0-9._-]{0,35}$"
-                },
-                $createdAt: {
-                    type: "string",
-                    format: "date-time"
-                },
-                $updatedAt: {
-                    type: "string",
-                    format: "date-time"
-                },
-                $permissions: {
-                    type: "array",
-                    items: {
-                        type: "string"
-                    }
-                }
-            },
-            required: ["$id", "$createdAt", "$updatedAt"],
-            additionalProperties: false
-        };
-        // Add custom attributes
-        const requiredFields = [...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
-                };
-            });
-        }
-        return schema;
-    }
-    generateJsonSchemas(options = {}) {
-        const { outputFormat = "both", outputDirectory = "schemas", verbose = false } = options;
-        if (!this.config.collections) {
-            if (verbose) {
-                MessageFormatter.warning("No collections found in config", { prefix: "Schema" });
-            }
-            return;
-        }
-        // Create JSON schemas directory using provided outputDirectory
-        const jsonSchemasPath = path.isAbsolute(outputDirectory)
-            ? outputDirectory
-            : path.join(this.appwriteFolderPath, outputDirectory);
-        if (!fs.existsSync(jsonSchemasPath)) {
-            fs.mkdirSync(jsonSchemasPath, { recursive: true });
-        }
-        if (verbose) {
-            MessageFormatter.processing(`Generating JSON schemas for ${this.config.collections.length} collections...`, { prefix: "Schema" });
-        }
-        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) {
-                    MessageFormatter.success(`JSON schema written to ${jsonPath}`, { prefix: "Schema" });
-                }
-            }
-            // 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) {
-                    MessageFormatter.success(`TypeScript schema written to ${tsPath}`, { prefix: "Schema" });
-                }
-            }
-        });
-        // Generate index file only for TypeScript output
-        if (outputFormat === "typescript" || outputFormat === "both") {
-            this.generateIndexFile(outputFormat, jsonSchemasPath, verbose);
-        }
-        if (verbose) {
-            MessageFormatter.success("JSON schema generation completed", { prefix: "Schema" });
-        }
-    }
-    generateTypeScriptSchema(schema, collectionName) {
-        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;
-`;
-    }
-    generateIndexFile(outputFormat, jsonSchemasPath, verbose) {
-        if (!this.config.collections)
-            return;
-        const indexPath = path.join(jsonSchemasPath, "index.ts");
-        const imports = [];
-        const exports = [];
-        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) {
-            MessageFormatter.success(`Index file written to ${indexPath}`, { prefix: "Schema" });
-        }
-    }
-    validateSchema(schema) {
-        const errors = [];
-        // 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 };
-    }
-}