appwrite-utils-cli 0.10.85 → 1.0.1

package/dist/config/yamlConfig.js

@@ -0,0 +1,452 @@
+import { z } from "zod";
+import yaml from "js-yaml";
+import fs from "fs";
+import path from "path";
+import { AppwriteConfigSchema, RuntimeSchema, FunctionScopes, FunctionSpecifications, permissionsSchema, PermissionToAppwritePermission } from "appwrite-utils";
+const YamlConfigSchema = z.object({
+    appwrite: z.object({
+        endpoint: z.string().default("https://cloud.appwrite.io/v1"),
+        project: z.string(),
+        key: z.string(),
+    }),
+    logging: z
+        .object({
+        enabled: z.boolean().default(false),
+        level: z.enum(["error", "warn", "info", "debug"]).default("info"),
+        directory: z.string().optional(),
+        console: z.boolean().default(false),
+    })
+        .optional()
+        .default({ enabled: false, level: "info", console: false }),
+    backups: z
+        .object({
+        enabled: z.boolean().default(true),
+        interval: z.number().default(3600),
+        retention: z.number().default(30),
+        cleanup: z.boolean().default(true),
+    })
+        .optional()
+        .default({ enabled: true, interval: 3600, retention: 30, cleanup: true }),
+    data: z
+        .object({
+        enableMockData: z.boolean().default(false),
+        documentBucketId: z.string().default("documents"),
+        usersCollectionName: z.string().default("Members"),
+        importDirectory: z.string().default("importData"),
+    })
+        .optional()
+        .default({
+        enableMockData: false,
+        documentBucketId: "documents",
+        usersCollectionName: "Members",
+        importDirectory: "importData",
+    }),
+    schemas: z
+        .object({
+        outputDirectory: z.string().default("schemas"),
+        yamlSchemaDirectory: z.string().default(".yaml_schemas"),
+    })
+        .optional()
+        .default({
+        outputDirectory: "schemas",
+        yamlSchemaDirectory: ".yaml_schemas",
+    }),
+    migrations: z
+        .object({
+        enabled: z.boolean().default(true),
+    })
+        .optional()
+        .default({
+        enabled: true,
+    }),
+    databases: z
+        .array(z.object({
+        id: z.string(),
+        name: z.string(),
+        bucket: z
+            .object({
+            id: z.string(),
+            name: z.string(),
+            permissions: permissionsSchema,
+            fileSecurity: z.boolean().optional(),
+            enabled: z.boolean().optional(),
+            maximumFileSize: z.number().optional(),
+            allowedFileExtensions: z.array(z.string()).optional(),
+            compression: z.enum(["none", "gzip", "zstd"]).optional(),
+            encryption: z.boolean().optional(),
+            antivirus: z.boolean().optional(),
+        })
+            .optional(),
+    }))
+        .optional()
+        .default([
+        { id: "dev", name: "Development" },
+        { id: "main", name: "Main" },
+        { id: "staging", name: "Staging" },
+    ]),
+    buckets: z
+        .array(z.object({
+        id: z.string(),
+        name: z.string(),
+        permissions: permissionsSchema,
+        fileSecurity: z.boolean().optional(),
+        enabled: z.boolean().optional(),
+        maximumFileSize: z.number().optional(),
+        allowedFileExtensions: z.array(z.string()).optional(),
+        compression: z.enum(["none", "gzip", "zstd"]).optional(),
+        encryption: z.boolean().optional(),
+        antivirus: z.boolean().optional(),
+    }))
+        .optional()
+        .default([]),
+    functions: z
+        .array(z.object({
+        id: z.string(),
+        name: z.string(),
+        runtime: RuntimeSchema,
+        execute: z.array(z.string()).optional(),
+        events: z.array(z.string()).optional(),
+        schedule: z.string().optional(),
+        timeout: z.number().optional(),
+        enabled: z.boolean().optional(),
+        logging: z.boolean().optional(),
+        entrypoint: z.string().optional(),
+        commands: z.string().optional(),
+        scopes: z.array(FunctionScopes).optional(),
+        installationId: z.string().optional(),
+        providerRepositoryId: z.string().optional(),
+        providerBranch: z.string().optional(),
+        providerSilentMode: z.boolean().optional(),
+        providerRootDirectory: z.string().optional(),
+        templateRepository: z.string().optional(),
+        templateOwner: z.string().optional(),
+        templateRootDirectory: z.string().optional(),
+        templateBranch: z.string().optional(),
+        specification: FunctionSpecifications.optional(),
+    }))
+        .optional()
+        .default([]),
+});
+export const convertYamlToAppwriteConfig = (yamlConfig) => {
+    const appwriteConfig = {
+        appwriteEndpoint: yamlConfig.appwrite.endpoint,
+        appwriteProject: yamlConfig.appwrite.project,
+        appwriteKey: yamlConfig.appwrite.key,
+        appwriteClient: null,
+        logging: {
+            enabled: yamlConfig.logging.enabled,
+            level: yamlConfig.logging.level,
+            logDirectory: yamlConfig.logging.directory,
+            console: yamlConfig.logging.console,
+        },
+        enableBackups: yamlConfig.backups.enabled,
+        backupInterval: yamlConfig.backups.interval,
+        backupRetention: yamlConfig.backups.retention,
+        enableBackupCleanup: yamlConfig.backups.cleanup,
+        enableMockData: yamlConfig.data.enableMockData,
+        documentBucketId: yamlConfig.data.documentBucketId,
+        usersCollectionName: yamlConfig.data.usersCollectionName,
+        useMigrations: yamlConfig.migrations.enabled,
+        schemaConfig: {
+            outputDirectory: yamlConfig.schemas.outputDirectory,
+            yamlSchemaDirectory: yamlConfig.schemas.yamlSchemaDirectory,
+            importDirectory: yamlConfig.data.importDirectory,
+        },
+        databases: yamlConfig.databases.map((db) => ({
+            $id: db.id,
+            name: db.name,
+            bucket: db.bucket
+                ? {
+                    $id: db.bucket.id,
+                    name: db.bucket.name,
+                    $permissions: PermissionToAppwritePermission(db.bucket.permissions),
+                    fileSecurity: db.bucket.fileSecurity || false,
+                    enabled: db.bucket.enabled || true,
+                    maximumFileSize: db.bucket.maximumFileSize || 30000000,
+                    allowedFileExtensions: db.bucket.allowedFileExtensions || [],
+                    compression: db.bucket.compression || "none",
+                    encryption: db.bucket.encryption || false,
+                    antivirus: db.bucket.antivirus || false,
+                }
+                : undefined,
+        })),
+        buckets: yamlConfig.buckets.map((bucket) => ({
+            $id: bucket.id,
+            name: bucket.name,
+            $permissions: PermissionToAppwritePermission(bucket.permissions),
+            fileSecurity: bucket.fileSecurity || false,
+            enabled: bucket.enabled || true,
+            maximumFileSize: bucket.maximumFileSize || 30000000,
+            allowedFileExtensions: bucket.allowedFileExtensions || [],
+            compression: bucket.compression || "none",
+            encryption: bucket.encryption || false,
+            antivirus: bucket.antivirus || false,
+        })),
+        functions: yamlConfig.functions?.map((func) => ({
+            $id: func.id,
+            name: func.name,
+            runtime: func.runtime,
+            execute: func.execute || [],
+            events: func.events || [],
+            schedule: func.schedule || "",
+            timeout: func.timeout || 15,
+            enabled: func.enabled || true,
+            logging: func.logging || true,
+            entrypoint: func.entrypoint || "",
+            commands: func.commands || "",
+            scopes: func.scopes || [],
+            installationId: func.installationId || "",
+            providerRepositoryId: func.providerRepositoryId || "",
+            providerBranch: func.providerBranch || "",
+            providerSilentMode: func.providerSilentMode || false,
+            providerRootDirectory: func.providerRootDirectory || "",
+            templateRepository: func.templateRepository || "",
+            templateOwner: func.templateOwner || "",
+            templateRootDirectory: func.templateRootDirectory || "",
+            templateBranch: func.templateBranch || "",
+            specification: func.specification || "s-0.5vcpu-512mb",
+        })),
+        collections: [],
+    };
+    return appwriteConfig;
+};
+export const loadYamlConfig = async (configPath) => {
+    try {
+        const fileContent = fs.readFileSync(configPath, "utf8");
+        const yamlData = yaml.load(fileContent);
+        const yamlConfig = YamlConfigSchema.parse(yamlData);
+        return convertYamlToAppwriteConfig(yamlConfig);
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            console.error("❌ YAML config validation failed:");
+            error.errors.forEach((err) => {
+                console.error(`  ${err.path.join('.')} → ${err.message}`);
+            });
+        }
+        else {
+            console.error("❌ Error loading YAML config:", error instanceof Error ? error.message : error);
+            if (error instanceof Error && error.stack) {
+                console.error("Stack trace:", error.stack);
+            }
+        }
+        return null;
+    }
+};
+export const findYamlConfig = (startDir) => {
+    // First check current directory for YAML configs
+    const possiblePaths = [
+        path.join(startDir, ".appwrite", "appwriteConfig.yaml"),
+        path.join(startDir, ".appwrite", "appwriteConfig.yml"),
+        path.join(startDir, ".appwrite", "config.yaml"),
+        path.join(startDir, ".appwrite", "config.yml"),
+        path.join(startDir, "appwrite.yaml"),
+        path.join(startDir, "appwrite.yml"),
+    ];
+    for (const configPath of possiblePaths) {
+        if (fs.existsSync(configPath)) {
+            return configPath;
+        }
+    }
+    // Recursively search subdirectories for .appwrite folders
+    const yamlConfigInSubdirs = findYamlConfigRecursive(startDir);
+    if (yamlConfigInSubdirs) {
+        return yamlConfigInSubdirs;
+    }
+    // Only check one level up to avoid infinite traversal
+    const parentDir = path.dirname(startDir);
+    if (parentDir !== startDir && path.basename(parentDir) !== 'node_modules') {
+        const parentPossiblePaths = [
+            path.join(parentDir, ".appwrite", "appwriteConfig.yaml"),
+            path.join(parentDir, ".appwrite", "appwriteConfig.yml"),
+            path.join(parentDir, "appwrite.yaml"),
+            path.join(parentDir, "appwrite.yml"),
+        ];
+        for (const configPath of parentPossiblePaths) {
+            if (fs.existsSync(configPath)) {
+                return configPath;
+            }
+        }
+    }
+    return null;
+};
+const shouldIgnoreDirectory = (dirName) => {
+    const ignoredDirs = [
+        'node_modules',
+        'dist',
+        'build',
+        'coverage',
+        '.next',
+        '.nuxt',
+        '.cache',
+        '.git',
+        '.svn',
+        '.hg',
+        '__pycache__',
+        '.pytest_cache',
+        '.mypy_cache',
+        'venv',
+        '.venv',
+        'env',
+        '.env',
+        'target',
+        'out',
+        'bin',
+        'obj',
+        '.vs',
+        '.vscode',
+        '.idea',
+        'temp',
+        'tmp',
+        '.tmp',
+        'logs',
+        'log',
+        '.DS_Store',
+        'Thumbs.db'
+    ];
+    return ignoredDirs.includes(dirName) ||
+        dirName.startsWith('.git') ||
+        dirName.startsWith('node_modules') ||
+        dirName.startsWith('.');
+};
+const findYamlConfigRecursive = (dir, depth = 0) => {
+    // Limit search depth to prevent infinite recursion
+    if (depth > 5) {
+        return null;
+    }
+    if (shouldIgnoreDirectory(path.basename(dir))) {
+        return null;
+    }
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory() && !shouldIgnoreDirectory(entry.name)) {
+                const fullPath = path.join(dir, entry.name);
+                // Check if this is an .appwrite directory
+                if (entry.name === ".appwrite") {
+                    const configPaths = [
+                        path.join(fullPath, "appwriteConfig.yaml"),
+                        path.join(fullPath, "appwriteConfig.yml"),
+                        path.join(fullPath, "config.yaml"),
+                        path.join(fullPath, "config.yml"),
+                    ];
+                    for (const configPath of configPaths) {
+                        if (fs.existsSync(configPath)) {
+                            return configPath;
+                        }
+                    }
+                }
+                // Recurse into other directories with increased depth
+                const result = findYamlConfigRecursive(fullPath, depth + 1);
+                if (result)
+                    return result;
+            }
+        }
+    }
+    catch (error) {
+        // Ignore directory access errors
+    }
+    return null;
+};
+export const generateYamlConfigTemplate = (outputPath) => {
+    const template = {
+        appwrite: {
+            endpoint: "https://cloud.appwrite.io/v1",
+            project: "YOUR_PROJECT_ID",
+            key: "YOUR_API_KEY",
+        },
+        logging: {
+            enabled: false,
+            level: "info",
+            console: false,
+        },
+        backups: {
+            enabled: true,
+            interval: 3600,
+            retention: 30,
+            cleanup: true,
+        },
+        data: {
+            enableMockData: false,
+            documentBucketId: "documents",
+            usersCollectionName: "Members",
+            importDirectory: "importData",
+        },
+        schemas: {
+            outputDirectory: "schemas",
+            yamlSchemaDirectory: ".yaml_schemas",
+        },
+        migrations: {
+            enabled: true,
+        },
+        databases: [
+            { id: "dev", name: "Development" },
+            { id: "main", name: "Main" },
+            { id: "staging", name: "Staging" },
+        ],
+        buckets: [],
+        functions: [],
+    };
+    const yamlContent = yaml.dump(template, {
+        indent: 2,
+        lineWidth: 120,
+        sortKeys: false,
+    });
+    // Add schema reference header
+    const schemaReference = "# yaml-language-server: $schema=./.yaml_schemas/appwrite-config.schema.json\n";
+    const finalContent = schemaReference + "# Appwrite Project Configuration\n" + yamlContent;
+    fs.writeFileSync(outputPath, finalContent, "utf8");
+};
+/**
+ * Adds a new function to the YAML config file
+ * @param configPath Path to the YAML config file
+ * @param newFunction The function configuration to add
+ */
+export const addFunctionToYamlConfig = async (configPath, newFunction) => {
+    try {
+        // Read current config
+        const fileContent = fs.readFileSync(configPath, "utf8");
+        const yamlData = yaml.load(fileContent);
+        // Initialize functions array if it doesn't exist
+        if (!yamlData.functions) {
+            yamlData.functions = [];
+        }
+        // Convert AppwriteFunction to YAML format
+        const yamlFunction = {
+            id: newFunction.$id,
+            name: newFunction.name,
+            runtime: newFunction.runtime,
+            execute: newFunction.execute || ["any"],
+            events: newFunction.events || [],
+            schedule: newFunction.schedule || "",
+            timeout: newFunction.timeout || 15,
+            enabled: newFunction.enabled !== false,
+            logging: newFunction.logging !== false,
+            entrypoint: newFunction.entrypoint || "",
+            commands: newFunction.commands || "",
+            scopes: newFunction.scopes || [],
+            specification: newFunction.specification || "s-0.5vcpu-512mb"
+        };
+        // Add new function
+        yamlData.functions.push(yamlFunction);
+        // Write back to file
+        const updatedYamlContent = yaml.dump(yamlData, {
+            indent: 2,
+            lineWidth: 120,
+            sortKeys: false,
+        });
+        // Preserve schema reference if it exists
+        const lines = fileContent.split('\n');
+        const schemaLine = lines.find(line => line.startsWith('# yaml-language-server:'));
+        let finalContent = updatedYamlContent;
+        if (schemaLine) {
+            finalContent = schemaLine + '\n' + updatedYamlContent;
+        }
+        fs.writeFileSync(configPath, finalContent, "utf8");
+        console.log(`✅ Added function "${newFunction.name}" to YAML config`);
+    }
+    catch (error) {
+        console.error("❌ Error adding function to YAML config:", error instanceof Error ? error.message : error);
+        throw error;
+    }
+};

package/dist/databases/setup.d.ts

@@ -0,0 +1,6 @@
+import { Databases, type Models } from "node-appwrite";
+import { type AppwriteConfig } from "appwrite-utils";
+export declare const setupMigrationDatabase: (config: AppwriteConfig) => Promise<void>;
+export declare const ensureDatabasesExist: (config: AppwriteConfig, databasesToEnsure?: Models.Database[]) => Promise<void>;
+export declare const wipeOtherDatabases: (database: Databases, databasesToKeep: Models.Database[], useMigrations?: boolean) => Promise<void>;
+export declare const ensureCollectionsExist: (config: AppwriteConfig, database: Models.Database, collectionsToEnsure?: Models.Collection[]) => Promise<void>;

package/dist/databases/setup.js

@@ -0,0 +1,119 @@
+import { Databases, Query } from "node-appwrite";
+import { createOrUpdateAttribute } from "../collections/attributes.js";
+import { getMigrationCollectionSchemas } from "../storage/schemas.js";
+import { areCollectionNamesSame, delay, toCamelCase, tryAwaitWithRetry, } from "../utils/index.js";
+import {} from "appwrite-utils";
+import { ulid } from "ulidx";
+export const setupMigrationDatabase = async (config) => {
+    if (!config.useMigrations) {
+        console.log("Migrations database disabled, skipping setup");
+        return;
+    }
+    console.log("---------------------------------");
+    console.log("Starting Migrations Setup");
+    console.log("---------------------------------");
+    const database = new Databases(config.appwriteClient);
+    if (!config.appwriteClient) {
+        throw new Error("Appwrite client is not initialized in the config");
+    }
+    let db;
+    const migrationCollectionsSetup = getMigrationCollectionSchemas();
+    try {
+        db = await tryAwaitWithRetry(async () => await database.get("migrations"), undefined, true);
+        console.log("Migrations database found");
+    }
+    catch (e) {
+        db = await tryAwaitWithRetry(async () => await database.create("migrations", "Migrations", true));
+        console.log("Migrations database created");
+    }
+    if (!db) {
+        console.error("Failed to create or retrieve the migrations database");
+        return;
+    }
+    for (const [collectionName, { collection, attributes }] of Object.entries(migrationCollectionsSetup)) {
+        const collectionId = toCamelCase(collectionName);
+        let collectionFound;
+        try {
+            collectionFound = await tryAwaitWithRetry(async () => await database.getCollection(db.$id, collectionId), undefined, true);
+            console.log(`Collection found: ${collectionId}`);
+        }
+        catch (e) {
+            console.log(`Collection not found: ${collectionId}`);
+            try {
+                collectionFound = await tryAwaitWithRetry(async () => await database.createCollection(db.$id, collectionId, collectionName, undefined, collection.documentSecurity, collection.enabled), undefined, true);
+                console.log(`Collection created: ${collectionId}`);
+            }
+            catch (createError) {
+                console.error(`Failed to create collection: ${collectionId}`, createError);
+                continue;
+            }
+        }
+        if (!collectionFound) {
+            console.error(`Failed to create or retrieve collection: ${collectionId}`);
+            continue;
+        }
+        for (const attribute of attributes) {
+            try {
+                await createOrUpdateAttribute(database, db.$id, collectionFound, attribute);
+                await delay(100);
+                console.log(`Attribute created/updated: ${attribute.key}`);
+            }
+            catch (attrError) {
+                console.error(`Failed to create/update attribute: ${attribute.key}`, attrError);
+            }
+        }
+    }
+    console.log("---------------------------------");
+    console.log("Migrations Setup Complete");
+    console.log("---------------------------------");
+};
+export const ensureDatabasesExist = async (config, databasesToEnsure) => {
+    if (!config.appwriteClient) {
+        throw new Error("Appwrite client is not initialized in the config");
+    }
+    const database = new Databases(config.appwriteClient);
+    const databasesToCreate = databasesToEnsure || config.databases || [];
+    if (!databasesToCreate.length) {
+        console.log("No databases to create");
+        return;
+    }
+    const existingDatabases = await tryAwaitWithRetry(async () => await database.list([Query.limit(500)]));
+    const migrationsDatabase = existingDatabases.databases.find((d) => d.name.toLowerCase().trim().replace(" ", "") === "migrations");
+    if (config.useMigrations && existingDatabases.databases.length !== 0 && migrationsDatabase) {
+        console.log("Creating all databases including migrations");
+        databasesToCreate.push(migrationsDatabase);
+    }
+    for (const db of databasesToCreate) {
+        if (!existingDatabases.databases.some((d) => d.name === db.name)) {
+            await tryAwaitWithRetry(async () => await database.create(db.$id || ulid(), db.name, true));
+            console.log(`${db.name} database created`);
+        }
+    }
+};
+export const wipeOtherDatabases = async (database, databasesToKeep, useMigrations = true) => {
+    console.log(`Databases to keep: ${databasesToKeep.map(db => db.name).join(", ")}`);
+    const allDatabases = await tryAwaitWithRetry(async () => await database.list([Query.limit(500)]));
+    const migrationsDatabase = allDatabases.databases.find((d) => d.name.toLowerCase().trim().replace(" ", "") === "migrations");
+    if (useMigrations && allDatabases.databases.length !== 0 && migrationsDatabase) {
+        console.log("Wiping all databases except migrations");
+        databasesToKeep.push(migrationsDatabase);
+    }
+    for (const db of allDatabases.databases) {
+        if (!databasesToKeep.some((d) => d.name === db.name)) {
+            await tryAwaitWithRetry(async () => await database.delete(db.$id));
+            console.log(`Deleted database: ${db.name}`);
+        }
+    }
+};
+export const ensureCollectionsExist = async (config, database, collectionsToEnsure) => {
+    const databaseClient = new Databases(config.appwriteClient);
+    const collectionsToCreate = collectionsToEnsure ||
+        (config.collections ? config.collections : []);
+    const existingCollections = await tryAwaitWithRetry(async () => await databaseClient.listCollections(database.$id, [Query.limit(500)]));
+    for (const collection of collectionsToCreate) {
+        if (!existingCollections.collections.some((c) => c.name === collection.name)) {
+            await tryAwaitWithRetry(async () => await databaseClient.createCollection(database.$id, ulid(), collection.name, undefined, true, true));
+            console.log(`${collection.name} collection created in ${database.name}`);
+        }
+    }
+};

package/dist/functions/methods.d.ts

@@ -12,4 +12,4 @@ export declare const createFunction: (client: Client, functionConfig: AppwriteFu
 export declare const updateFunctionSpecifications: (client: Client, functionId: string, specification: Specification) => Promise<import("node-appwrite").Models.Function | undefined>;
 export declare const listSpecifications: (client: Client) => Promise<import("node-appwrite").Models.SpecificationList>;
 export declare const updateFunction: (client: Client, functionConfig: AppwriteFunction) => Promise<import("node-appwrite").Models.Function>;
-export declare const createFunctionTemplate: (templateType: "typescript-node" | "poetry" | "count-docs-in-collection", functionName: string, basePath?: string) => Promise<string>;
+export declare const createFunctionTemplate: (templateType: "typescript-node" | "uv" | "count-docs-in-collection", functionName: string, basePath?: string) => Promise<string>;

package/dist/functions/methods.js

@@ -1,5 +1,6 @@
 import { AppwriteException, Client, Functions, Query, Runtime, } from "node-appwrite";
-import { join } from "node:path";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
 import fs from "node:fs";
 import {} from "appwrite-utils";
 import chalk from "chalk";
@@ -100,7 +101,9 @@ export const updateFunction = async (client, functionConfig) => {
 };
 export const createFunctionTemplate = async (templateType, functionName, basePath = "./functions") => {
     const functionPath = join(basePath, functionName);
-    const templatesPath = join(__dirname, "templates", templateType);
+    const currentFileUrl = import.meta.url;
+    const currentDir = dirname(fileURLToPath(currentFileUrl));
+    const templatesPath = join(currentDir, "templates", templateType);
     // Create function directory
     await fs.promises.mkdir(functionPath, { recursive: true });
     // Copy template files recursively

package/dist/functions/openapi.d.ts

@@ -0,0 +1,4 @@
+import { type AppwriteConfig } from "appwrite-utils";
+import { z } from "zod";
+export declare const generateOpenApi: (config: AppwriteConfig) => Promise<void>;
+export declare function transformTypeToOpenApi<T extends z.ZodTypeAny>(schema: T, description?: string | Record<string, any> | null | undefined): T;

package/dist/functions/openapi.js

@@ -0,0 +1,60 @@
+import { OpenAPIRegistry, OpenApiGeneratorV3, OpenApiGeneratorV31, } from "@asteasolutions/zod-to-openapi";
+import { attributeSchema, CollectionSchema, } from "appwrite-utils";
+import { z } from "zod";
+import { writeFileSync } from "fs";
+const registry = new OpenAPIRegistry();
+export const generateOpenApi = async (config) => {
+    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(schema, description) {
+    // Check if description is an object (OpenAPI properties) or a string
+    let updatedSchema;
+    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._def && schema._def.shape) {
+        const shape = schema._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;
+}