deploy.js

const inquirer = require("inquirer");
const JSONbig = require("json-bigint")({ storeAsString: false });
const { Command } = require("commander");
const { localConfig } = require("../config");
const { questionsDeployBuckets, questionsDeployTeams, questionsDeployFunctions, questionsGetEntrypoint, questionsDeployCollections, questionsConfirmDeployCollections } = require("../questions");
const { actionRunner, success, log, error, commandDescriptions } = require("../parser");
const { functionsGet, functionsCreate, functionsUpdate, functionsCreateDeployment, functionsUpdateDeployment, functionsListVariables, functionsDeleteVariable, functionsCreateVariable } = require('./functions');
const {
    databasesGet,
    databasesCreate,
    databasesUpdate,
    databasesCreateBooleanAttribute,
    databasesGetCollection,
    databasesCreateCollection,
    databasesCreateStringAttribute,
    databasesCreateIntegerAttribute,
    databasesCreateFloatAttribute,
    databasesCreateEmailAttribute,
    databasesCreateDatetimeAttribute,
    databasesCreateIndex,
    databasesCreateUrlAttribute,
    databasesCreateIpAttribute,
    databasesCreateEnumAttribute,
    databasesCreateRelationshipAttribute,
    databasesDeleteAttribute,
    databasesListAttributes,
    databasesListIndexes,
    databasesDeleteIndex,
    databasesUpdateCollection
} = require("./databases");
const {
    storageGetBucket, storageUpdateBucket, storageCreateBucket
} = require("./storage");
const {
    teamsGet,
    teamsUpdate,
    teamsCreate
} = require("./teams");

const POOL_DEBOUNCE = 2000; // in milliseconds
const POOL_MAX_DEBOUNCES = 30;

const awaitPools = {
    wipeAttributes: async (databaseId, collectionId, iteration = 1) => {
        if (iteration > POOL_MAX_DEBOUNCES) {
            return false;
        }

        // TODO: Pagination?
        const { attributes: remoteAttributes } = await databasesListAttributes({
            databaseId,
            collectionId,
            queries: ['limit(100)'],
            parseOutput: false
        });

        if (remoteAttributes.length <= 0) {
            return true;
        }

        await new Promise(resolve => setTimeout(resolve, POOL_DEBOUNCE));
        return await awaitPools.wipeAttributes(databaseId, collectionId, iteration + 1);
    },
    wipeIndexes: async (databaseId, collectionId, iteration = 1) => {
        if (iteration > POOL_MAX_DEBOUNCES) {
            return false;
        }

        // TODO: Pagination?
        const { indexes: remoteIndexes } = await databasesListIndexes({
            databaseId,
            collectionId,
            queries: ['limit(100)'],
            parseOutput: false
        });

        if (remoteIndexes.length <= 0) {
            return true;
        }

        await new Promise(resolve => setTimeout(resolve, POOL_DEBOUNCE));
        return await awaitPools.wipeIndexes(databaseId, collectionId, iteration + 1);
    },
    expectAttributes: async (databaseId, collectionId, attributeKeys, iteration = 1) => {
        if (iteration > POOL_MAX_DEBOUNCES) {
            return false;
        }

        // TODO: Pagination?
        const { attributes: remoteAttributes } = await databasesListAttributes({
            databaseId,
            collectionId,
            queries: ['limit(100)'],
            parseOutput: false
        });

        const readyAttributeKeys = remoteAttributes.filter((attribute) => {
            if (attributeKeys.includes(attribute.key)) {
                if (['stuck', 'failed'].includes(attribute.status)) {
                    throw new Error(`Attribute '${attribute.key}' failed!`);
                }

                return attribute.status === 'available';
            }

            return false;
        }).map(attribute => attribute.key);

        if (readyAttributeKeys.length >= attributeKeys.length) {
            return true;
        }

        await new Promise(resolve => setTimeout(resolve, POOL_DEBOUNCE));
        return await awaitPools.expectAttributes(databaseId, collectionId, attributeKeys, iteration + 1);
    },
    expectIndexes: async (databaseId, collectionId, indexKeys, iteration = 1) => {
        if (iteration > POOL_MAX_DEBOUNCES) {
            return false;
        }

        // TODO: Pagination?
        const { indexes: remoteIndexes } = await databasesListIndexes({
            databaseId,
            collectionId,
            queries: ['limit(100)'],
            parseOutput: false
        });

        const readyIndexKeys = remoteIndexes.filter((index) => {
            if (indexKeys.includes(index.key)) {
                if (['stuck', 'failed'].includes(index.status)) {
                    throw new Error(`Index '${index.key}' failed!`);
                }

                return index.status === 'available';
            }

            return false;
        }).map(index => index.key);

        if (readyIndexKeys.length >= indexKeys.length) {
            return true;
        }

        await new Promise(resolve => setTimeout(resolve, POOL_DEBOUNCE));
        return await awaitPools.expectIndexes(databaseId, collectionId, indexKeys, iteration + 1);
    },
}

const deploy = new Command("deploy")
    .description(commandDescriptions['deploy'])
    .configureHelp({
        helpWidth: process.stdout.columns || 80
    })
    .action(actionRunner(async (_options, command) => {
        command.help()
    }));

const deployFunction = async ({ functionId, all, yes } = {}) => {
    let response = {};

    const functionIds = [];

    if (functionId) {
        functionIds.push(functionId);
    } else if (all) {
        const functions = localConfig.getFunctions();
        if (functions.length === 0) {
            throw new Error("No functions found in the current directory.");
        }
        functionIds.push(...functions.map((func, idx) => {
            return func.$id;
        }));
    }

    if (functionIds.length <= 0) {
        const answers = await inquirer.prompt(questionsDeployFunctions[0]);
        functionIds.push(...answers.functions);
    }

    let functions = functionIds.map((id) => {
        const functions = localConfig.getFunctions();
        const func = functions.find((f) => f.$id === id);

        if (!func) {
            throw new Error("Function '" + id + "' not found.")
        }

        return func;
    });

    for (let func of functions) {
        log(`Deploying function ${func.name} ( ${func['$id']} )`)

        try {
            response = await functionsGet({
                functionId: func['$id'],
                parseOutput: false,
            });

            if (response.runtime !== func.runtime) {
                throw new Error(`Runtime missmatch! (local=${func.runtime},remote=${response.runtime}) Please delete remote function or update your appwrite.json`);
            }

            response = await functionsUpdate({
                functionId: func['$id'],
                name: func.name,
                execute: func.execute,
                events: func.events,
                schedule: func.schedule,
                timeout: func.timeout,
                enabled: func.enabled,
                logging: func.logging,
                entrypoint: func.entrypoint,
                commands: func.commands,
                vars: JSON.stringify(response.vars),
                parseOutput: false
            });
        } catch (e) {
            if (e.code == 404) {
                log(`Function ${func.name} ( ${func['$id']} ) does not exist in the project. Creating ... `);
                response = await functionsCreate({
                    functionId: func.$id || 'unique()',
                    name: func.name,
                    runtime: func.runtime,
                    execute: func.execute,
                    events: func.events,
                    schedule: func.schedule,
                    timeout: func.timeout,
                    enabled: func.enabled,
                    logging: func.logging,
                    entrypoint: func.entrypoint,
                    commands: func.commands,
                    vars: JSON.stringify(func.vars),
                    parseOutput: false
                });

                localConfig.updateFunction(func['$id'], {
                    "$id": response['$id'],
                });

                func["$id"] = response['$id'];
                log(`Function ${func.name} created.`);
            } else {
                throw e;
            }
        }

        if (func.variables) {
            // Delete existing variables

            // TODO: Pagination?
            const { variables: remoteVariables } = await functionsListVariables({
                functionId: func['$id'],
                queries: ['limit(100)'],
                parseOutput: false
            });

            let deployVariables = yes;
            if (remoteVariables.length == 0) {
                deployVariables = true;
            } else if (remoteVariables.length > 0 && !yes) {
                const variableAnswers = await inquirer.prompt(questionsDeployFunctions[1])
                deployVariables = variableAnswers.override === "YES";
            }

            if (!deployVariables) {
                log(`Skipping variables for ${func.name} ( ${func['$id']} )`);
            } else {
                log(`Deploying variables for ${func.name} ( ${func['$id']} )`);

                await Promise.all(remoteVariables.map(async remoteVariable => {
                    await functionsDeleteVariable({
                        functionId: func['$id'],
                        variableId: remoteVariable['$id'],
                        parseOutput: false
                    });
                }));

                // Deploy local variables
                await Promise.all(Object.keys(func.variables).map(async localVariableKey => {
                    await functionsCreateVariable({
                        functionId: func['$id'],
                        key: localVariableKey,
                        value: func.variables[localVariableKey],
                        parseOutput: false
                    });
                }));
            }
        }

        // Create tag
        if (!func.entrypoint) {
            answers = await inquirer.prompt(questionsGetEntrypoint)
            func.entrypoint = answers.entrypoint;
            localConfig.updateFunction(func['$id'], func);
        }

        try {
            response = await functionsCreateDeployment({
                functionId: func['$id'],
                entrypoint: func.entrypoint,
                commands: func.commands,
                code: func.path,
                activate: true,
                parseOutput: false
            })

            success(`Deployed ${func.name} ( ${func['$id']} )`);

        } catch (e) {
            switch (e.code) {
                case 'ENOENT':
                    error(`Function ${func.name} ( ${func['$id']} ) not found in the current directory. Skipping ...`);
                    break;
                default:
                    throw e;
            }
        }
    }

    success(`Deployed ${functions.length} functions`);
}

const createAttribute = async (databaseId, collectionId, attribute) => {
    switch (attribute.type) {
        case 'string':
            switch (attribute.format) {
                case 'email':
                    return await databasesCreateEmailAttribute({
                        databaseId,
                        collectionId,
                        key: attribute.key,
                        required: attribute.required,
                        xdefault: attribute.default,
                        array: attribute.array,
                        parseOutput: false
                    })
                case 'url':
                    return await databasesCreateUrlAttribute({
                        databaseId,
                        collectionId,
                        key: attribute.key,
                        required: attribute.required,
                        xdefault: attribute.default,
                        array: attribute.array,
                        parseOutput: false
                    })
                case 'ip':
                    return await databasesCreateIpAttribute({
                        databaseId,
                        collectionId,
                        key: attribute.key,
                        required: attribute.required,
                        xdefault: attribute.default,
                        array: attribute.array,
                        parseOutput: false
                    })
                case 'enum':
                    return await databasesCreateEnumAttribute({
                        databaseId,
                        collectionId,
                        key: attribute.key,
                        elements: attribute.elements,
                        required: attribute.required,
                        xdefault: attribute.default,
                        array: attribute.array,
                        parseOutput: false
                    })
                default:
                    return await databasesCreateStringAttribute({
                        databaseId,
                        collectionId,
                        key: attribute.key,
                        size: attribute.size,
                        required: attribute.required,
                        xdefault: attribute.default,
                        array: attribute.array,
                        parseOutput: false
                    })

            }
        case 'integer':
            return await databasesCreateIntegerAttribute({
                databaseId,
                collectionId,
                key: attribute.key,
                required: attribute.required,
                min: attribute.min,
                max: attribute.max,
                xdefault: attribute.default,
                array: attribute.array,
                parseOutput: false
            })
        case 'double':
            return databasesCreateFloatAttribute({
                databaseId,
                collectionId,
                key: attribute.key,
                required: attribute.required,
                min: attribute.min,
                max: attribute.max,
                xdefault: attribute.default,
                array: attribute.array,
                parseOutput: false
            })
        case 'boolean':
            return databasesCreateBooleanAttribute({
                databaseId,
                collectionId,
                key: attribute.key,
                required: attribute.required,
                xdefault: attribute.default,
                array: attribute.array,
                parseOutput: false
            })
        case 'datetime':
            return databasesCreateDatetimeAttribute({
                databaseId,
                collectionId,
                key: attribute.key,
                required: attribute.required,
                xdefault: attribute.default,
                array: attribute.array,
                parseOutput: false
            })
        case 'relationship':
            return databasesCreateRelationshipAttribute({
                databaseId,
                collectionId,
                relatedCollectionId: attribute.relatedCollection,
                type: attribute.relationType,
                twoWay: attribute.twoWay,
                key: attribute.key,
                twoWayKey: attribute.twoWayKey,
                onDelete: attribute.onDelete,
                parseOutput: false
            })
    }
}

const deployCollection = async ({ all, yes } = {}) => {
    let response = {};

    const collections = [];

    if (all) {
        if (localConfig.getCollections().length === 0) {
            throw new Error("No collections found in the current directory. Run `appwrite init collection` to fetch all your collections.");
        }
        collections.push(...localConfig.getCollections());
    } else {
        const answers = await inquirer.prompt(questionsDeployCollections[0])
        const configCollections = new Map();
        localConfig.getCollections().forEach((c) => {
            configCollections.set(`${c['databaseId']}|${c['$id']}`, c);
        });
        answers.collections.forEach((a) => {
            const collection = configCollections.get(a);
            collections.push(collection);
        })
    }

    for (let collection of collections) {
        log(`Deploying collection ${collection.name} ( ${collection['databaseId']} - ${collection['$id']} )`)

        let databaseId;

        const localDatabase = localConfig.getDatabase(collection.databaseId);

        try {
            const database = await databasesGet({
                databaseId: collection.databaseId,
                parseOutput: false,
            });
            databaseId = database.$id;

            await databasesUpdate({
                databaseId: collection.databaseId,
                name: localDatabase.name ?? collection.databaseId,
                parseOutput: false
            })

            success(`Updated ${localDatabase.name} ( ${collection.databaseId} )`);
        } catch (err) {
            log(`Database ${collection.databaseId} not found. Creating it now...`);
            const database = await databasesCreate({
                databaseId: collection.databaseId,
                name: localDatabase.name ?? collection.databaseId,
                parseOutput: false,
            });
            databaseId = database.$id;
        }

        try {
            response = await databasesGetCollection({
                databaseId,
                collectionId: collection['$id'],
                parseOutput: false,
            })
            log(`Collection ${collection.name} ( ${collection['$id']} ) already exists.`);

            if (!yes) {
                answers = await inquirer.prompt(questionsDeployCollections[1])
                if (answers.override !== "YES") {
                    log(`Received "${answers.override}". Skipping ${collection.name} ( ${collection['$id']} )`);
                    continue;
                }
            }

            log(`Deleting indexes and attributes ... `);

            // TODO: Pagination?
            const { indexes: remoteIndexes } = await databasesListIndexes({
                databaseId,
                collectionId: collection['$id'],
                queries: ['limit(100)'],
                parseOutput: false
            });

            await Promise.all(remoteIndexes.map(async index => {
                await databasesDeleteIndex({
                    databaseId,
                    collectionId: collection['$id'],
                    key: index.key,
                    parseOutput: false
                });
            }));

            const deleteIndexesPoolStatus = await awaitPools.wipeIndexes(databaseId, collection['$id']);
            if (!deleteIndexesPoolStatus) {
                throw new Error("Index deletion did not finish for too long.");
            }

            // TODO: Pagination?
            const { attributes: remoteAttributes } = await databasesListAttributes({
                databaseId,
                collectionId: collection['$id'],
                queries: ['limit(100)'],
                parseOutput: false
            });

            await Promise.all(remoteAttributes.map(async attribute => {
                await databasesDeleteAttribute({
                    databaseId,
                    collectionId: collection['$id'],
                    key: attribute.key,
                    parseOutput: false
                });
            }));

            const deleteAttributesPoolStatus = await awaitPools.wipeAttributes(databaseId, collection['$id']);
            if (!deleteAttributesPoolStatus) {
                throw new Error("Attribute deletion did not finish for too long.");
            }

            await databasesUpdateCollection({
                databaseId,
                collectionId: collection['$id'],
                name: collection.name,
                documentSecurity: collection.documentSecurity,
                permissions: collection['$permissions'],
                enabled: collection.enabled,
                parseOutput: false
            })
        } catch (e) {
            if (e.code == 404) {
                log(`Collection ${collection.name} does not exist in the project. Creating ... `);
                response = await databasesCreateCollection({
                    databaseId,
                    collectionId: collection['$id'],
                    name: collection.name,
                    documentSecurity: collection.documentSecurity,
                    permissions: collection['$permissions'],
                    parseOutput: false
                })

            } else {
                throw e;
            }
        }

        // Create all non-relationship attributes first
        const nonRelationshipAttributes = collection.attributes.filter(attribute => attribute.type !== 'relationship');
        await Promise.all(nonRelationshipAttributes.map(attribute => {
            return createAttribute(databaseId, collection['$id'], attribute);
        }));

        const nonRelationshipAttributeKeys = nonRelationshipAttributes.map(attribute => attribute.key);
        const createPoolStatus = await awaitPools.expectAttributes(databaseId, collection['$id'], nonRelationshipAttributeKeys);
        if (!createPoolStatus) {
            throw new Error("Attribute creation did not finish for too long.");
        }

        success(`Created ${nonRelationshipAttributeKeys.length} non-relationship attributes`);

        log(`Creating indexes ...`)
        await Promise.all(collection.indexes.map(async index => {
            await databasesCreateIndex({
                databaseId,
                collectionId: collection['$id'],
                key: index.key,
                type: index.type,
                attributes: index.attributes,
                orders: index.orders,
                parseOutput: false
            });
        }));

        const indexKeys = collection.indexes.map(attribute => attribute.key);
        const indexPoolStatus = await awaitPools.expectIndexes(databaseId, collection['$id'], indexKeys);
        if (!indexPoolStatus) {
            throw new Error("Index creation did not finish for too long.");
        }

        success(`Created ${collection.indexes.length} indexes`);

        success(`Deployed ${collection.name} ( ${collection['$id']} )`);
    }

    // Create the relationship attributes
    for (let collection of collections) {
        const relationshipAttributes = collection.attributes.filter(attribute => attribute.type === 'relationship' && attribute.side === 'parent');

        if (relationshipAttributes.length === 0) continue;

        log(`Deploying relationships for collection ${collection.name} ( ${collection['$id']} )`);

        await Promise.all(relationshipAttributes.map(attribute => {
            return createAttribute(collection['databaseId'], collection['$id'], attribute);
        }));

        const nonRelationshipAttributeKeys = relationshipAttributes.map(attribute => attribute.key);
        const createPoolStatus = await awaitPools.expectAttributes(collection['databaseId'], collection['$id'], nonRelationshipAttributeKeys);
        if (!createPoolStatus) {
            throw new Error("Attribute creation did not finish for too long.");
        }

        success(`Created ${nonRelationshipAttributeKeys.length} relationship attributes`);
    }
}

const deployBucket = async ({ all, yes } = {}) => {
    let response = {};

    let bucketIds = [];
    const configBuckets = localConfig.getBuckets();

    if (all) {
        if (configBuckets.length === 0) {
            throw new Error("No buckets found in the current directory. Run `appwrite init bucket` to fetch all your buckets.");
        }
        bucketIds.push(...configBuckets.map((b) => b.$id));
    }

    if (bucketIds.length === 0) {
        let answers = await inquirer.prompt(questionsDeployBuckets[0])
        bucketIds.push(...answers.buckets);
    }

    let buckets = [];

    for (const bucketId of bucketIds) {
        const idBuckets = configBuckets.filter((b) => b.$id === bucketId);
        buckets.push(...idBuckets);
    }

    for (let bucket of buckets) {
        log(`Deploying bucket ${bucket.name} ( ${bucket['$id']} )`)

        try {
            response = await storageGetBucket({
                bucketId: bucket['$id'],
                parseOutput: false,
            })
            log(`Bucket ${bucket.name} ( ${bucket['$id']} ) already exists.`);

            if (!yes) {
                answers = await inquirer.prompt(questionsDeployBuckets[1])
                if (answers.override !== "YES") {
                    log(`Received "${answers.override}". Skipping ${bucket.name} ( ${bucket['$id']} )`);
                    continue;
                }
            }

            log(`Updating bucket ...`)

            await storageUpdateBucket({
                bucketId: bucket['$id'],
                name: bucket.name,
                permissions: bucket['$permissions'],
                fileSecurity: bucket.fileSecurity,
                enabled: bucket.enabled,
                maximumFileSize: bucket.maximumFileSize,
                allowedFileExtensions: bucket.allowedFileExtensions,
                compression: bucket.compression,
                encryption: bucket.encryption,
                antivirus: bucket.antivirus,
                compression: bucket.compression,
                parseOutput: false
            });

            success(`Deployed ${bucket.name} ( ${bucket['$id']} )`);
        } catch (e) {
            if (e.code == 404) {
                log(`Bucket ${bucket.name} does not exist in the project. Creating ... `);

                response = await storageCreateBucket({
                    bucketId: bucket['$id'],
                    name: bucket.name,
                    permissions: bucket['$permissions'],
                    fileSecurity: bucket.fileSecurity,
                    enabled: bucket.enabled,
                    maximumFileSize: bucket.maximumFileSize,
                    allowedFileExtensions: bucket.allowedFileExtensions,
                    compression: bucket.compression,
                    encryption: bucket.encryption,
                    antivirus: bucket.antivirus,
                    parseOutput: false
                })

                success(`Deployed ${bucket.name} ( ${bucket['$id']} )`);
            } else {
                throw e;
            }
        }
    }
}

const deployTeam = async ({ all, yes } = {}) => {
    let response = {};

    let teamIds = [];
    const configTeams = localConfig.getTeams();

    if (all) {
        if (configTeams.length === 0) {
            throw new Error("No teams found in the current directory. Run `appwrite init team` to fetch all your teams.");
        }
        teamIds.push(...configTeams.map((t) => t.$id));
    }

    if (teamIds.length === 0) {
        let answers = await inquirer.prompt(questionsDeployTeams[0])
        teamIds.push(...answers.teams);
    }

    let teams = [];

    for (const teamId of teamIds) {
        const idTeams = configTeams.filter((t) => t.$id === teamId);
        teams.push(...idTeams);
    }

    for (let team of teams) {
        log(`Deploying team ${team.name} ( ${team['$id']} )`)

        try {
            response = await teamsGet({
                teamId: team['$id'],
                parseOutput: false,
            })
            log(`Team ${team.name} ( ${team['$id']} ) already exists.`);

            if (!yes) {
                answers = await inquirer.prompt(questionsDeployTeams[1])
                if (answers.override !== "YES") {
                    log(`Received "${answers.override}". Skipping ${team.name} ( ${team['$id']} )`);
                    continue;
                }
            }

            log(`Updating team ...`)

            await teamsUpdate({
                teamId: team['$id'],
                name: team.name,
                parseOutput: false
            });

            success(`Deployed ${team.name} ( ${team['$id']} )`);
        } catch (e) {
            if (e.code == 404) {
                log(`Team ${team.name} does not exist in the project. Creating ... `);

                response = await teamsCreate({
                    teamId: team['$id'],
                    name: team.name,
                    parseOutput: false
                })

                success(`Deployed ${team.name} ( ${team['$id']} )`);
            } else {
                throw e;
            }
        }
    }
}

deploy
    .command("function")
    .description("Deploy functions in the current directory.")
    .option(`--functionId <functionId>`, `Function ID`)
    .option(`--all`, `Flag to deploy all functions`)
    .option(`--yes`, `Flag to confirm all warnings`)
    .action(actionRunner(deployFunction));

deploy
    .command("collection")
    .description("Deploy collections in the current project.")
    .option(`--all`, `Flag to deploy all functions`)
    .option(`--yes`, `Flag to confirm all warnings`)
    .action(actionRunner(deployCollection));

deploy
    .command("bucket")
    .description("Deploy buckets in the current project.")
    .option(`--all`, `Flag to deploy all buckets`)
    .option(`--yes`, `Flag to confirm all warnings`)
    .action(actionRunner(deployBucket));

deploy
    .command("team")
    .description("Deploy teams in the current project.")
    .option(`--all`, `Flag to deploy all teams`)
    .option(`--yes`, `Flag to confirm all warnings`)
    .action(actionRunner(deployTeam));

module.exports = {
    deploy
}