@njdamstra/appwrite-utils-cli 1.8.9

package/dist/databases/methods.d.ts

@@ -0,0 +1,6 @@
+import { Databases, type Models } from "node-appwrite";
+export declare const fetchAllDatabases: (database: Databases) => Promise<Models.Database[]>;
+export declare const wipeDatabase: (database: Databases, databaseId: string) => Promise<{
+    collectionId: string;
+    collectionName: string;
+}[]>;

package/dist/databases/methods.js

@@ -0,0 +1,35 @@
+import { Databases, Query } from "node-appwrite";
+import { delay, tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import { fetchAllCollections } from "../collections/methods.js";
+import { MessageFormatter } from "../shared/messageFormatter.js";
+export const fetchAllDatabases = async (database) => {
+    const databases = await tryAwaitWithRetry(async () => await database.list([Query.limit(25)]));
+    const allDatabases = databases.databases;
+    if (allDatabases.length === 0)
+        return [];
+    let lastDatabaseId = allDatabases[allDatabases.length - 1].$id;
+    while (databases.databases.length === 25) {
+        const moreDatabases = await database.list([
+            Query.limit(25),
+            Query.cursorAfter(lastDatabaseId),
+        ]);
+        allDatabases.push(...moreDatabases.databases);
+        if (moreDatabases.databases.length < 25)
+            break;
+        lastDatabaseId =
+            moreDatabases.databases[moreDatabases.databases.length - 1].$id;
+    }
+    return allDatabases;
+};
+export const wipeDatabase = async (database, databaseId) => {
+    MessageFormatter.info(`Wiping database: ${databaseId}`, { prefix: "Database" });
+    const existingCollections = await fetchAllCollections(databaseId, database);
+    let collectionsDeleted = [];
+    for (const { $id: collectionId, name } of existingCollections) {
+        MessageFormatter.info(`Deleting collection: ${collectionId}`, { prefix: "Database" });
+        collectionsDeleted.push({ collectionId, collectionName: name });
+        await tryAwaitWithRetry(async () => await database.deleteCollection(databaseId, collectionId));
+        await delay(100);
+    }
+    return collectionsDeleted;
+};

package/dist/databases/setup.d.ts

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

package/dist/databases/setup.js

@@ -0,0 +1,45 @@
+import { Databases, Query } from "node-appwrite";
+import { tryAwaitWithRetry } from "../utils/index.js";
+import {} from "@njdamstra/appwrite-utils";
+import { ulid } from "ulidx";
+import { MessageFormatter } from "../shared/messageFormatter.js";
+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) {
+        MessageFormatter.info("No databases to create");
+        return;
+    }
+    const existingDatabases = await tryAwaitWithRetry(async () => await database.list([Query.limit(500)]));
+    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));
+            MessageFormatter.success(`${db.name} database created`);
+        }
+    }
+};
+export const wipeOtherDatabases = async (database, databasesToKeep) => {
+    MessageFormatter.info(`Databases to keep: ${databasesToKeep.map(db => db.name).join(", ")}`);
+    const allDatabases = await tryAwaitWithRetry(async () => await database.list([Query.limit(500)]));
+    for (const db of allDatabases.databases) {
+        if (!databasesToKeep.some((d) => d.name === db.name)) {
+            await tryAwaitWithRetry(async () => await database.delete(db.$id));
+            MessageFormatter.success(`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));
+            MessageFormatter.success(`${collection.name} collection created in ${database.name}`);
+        }
+    }
+};

package/dist/examples/yamlTerminologyExample.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Example demonstrating YAML import/export with dual terminology support
+ *
+ * This example shows how to:
+ * 1. Generate YAML files for both collections and tables
+ * 2. Load and convert between terminologies
+ * 3. Validate terminology consistency
+ * 4. Migrate between formats
+ */
+import { type CollectionCreate } from "@njdamstra/appwrite-utils";
+/**
+ * Example 1: Generate YAML templates for both collection and table formats
+ */
+export declare function generateTemplateExamples(outputDir: string): Promise<void>;
+/**
+ * Example 2: Convert existing collection definition to different formats
+ */
+export declare function convertCollectionFormats(collection: CollectionCreate): void;
+/**
+ * Example 3: Load and process YAML files with mixed terminologies
+ */
+export declare function processYamlFiles(baseDir: string): Promise<void>;
+/**
+ * Example 4: Migrate between terminologies
+ */
+export declare function migrateTerminology(baseDir: string): Promise<void>;
+/**
+ * Example 5: Validate terminology consistency
+ */
+export declare function validateTerminology(baseDir: string): Promise<void>;
+/**
+ * Example 6: Import configuration with terminology support
+ */
+export declare function importConfigurationExample(appwriteFolderPath: string): Promise<void>;
+/**
+ * Example 7: Manual terminology conversion
+ */
+export declare function manualTerminologyConversion(): void;
+/**
+ * Main example runner
+ */
+export declare function runYamlTerminologyExamples(outputDir: string): Promise<void>;

package/dist/examples/yamlTerminologyExample.js

@@ -0,0 +1,272 @@
+/**
+ * Example demonstrating YAML import/export with dual terminology support
+ *
+ * This example shows how to:
+ * 1. Generate YAML files for both collections and tables
+ * 2. Load and convert between terminologies
+ * 3. Validate terminology consistency
+ * 4. Migrate between formats
+ */
+import { collectionToYaml, generateYamlTemplate, generateExampleYamls, convertTerminology, normalizeYamlData, usesTableTerminology } from "../utils/yamlConverter.js";
+import { createYamlLoader } from "../utils/yamlLoader.js";
+import { YamlImportIntegration } from "../migrations/yaml/YamlImportIntegration.js";
+import { createImportSchemas } from "../migrations/yaml/generateImportSchemas.js";
+import { CollectionCreateSchema } from "@njdamstra/appwrite-utils";
+import fs from "fs";
+import path from "path";
+/**
+ * Example 1: Generate YAML templates for both collection and table formats
+ */
+export async function generateTemplateExamples(outputDir) {
+    console.log("🚀 Generating YAML template examples...");
+    // Ensure output directories exist
+    const collectionsDir = path.join(outputDir, "collections");
+    const tablesDir = path.join(outputDir, "tables");
+    [collectionsDir, tablesDir].forEach(dir => {
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    });
+    // Generate schemas first
+    await createImportSchemas(outputDir);
+    // Generate examples for both formats
+    const examples = generateExampleYamls("Product");
+    // Save collection format
+    const collectionPath = path.join(collectionsDir, "Product.yaml");
+    fs.writeFileSync(collectionPath, examples.collection);
+    console.log(`✅ Generated collection YAML: ${collectionPath}`);
+    // Save table format
+    const tablePath = path.join(tablesDir, "Product.yaml");
+    fs.writeFileSync(tablePath, examples.table);
+    console.log(`✅ Generated table YAML: ${tablePath}`);
+}
+/**
+ * Example 2: Convert existing collection definition to different formats
+ */
+export function convertCollectionFormats(collection) {
+    console.log("🔄 Converting collection to different YAML formats...");
+    // Generate collection format YAML
+    const collectionConfig = {
+        useTableTerminology: false,
+        entityType: 'collection',
+        schemaPath: "../.yaml_schemas/collection.schema.json"
+    };
+    const collectionYaml = collectionToYaml(collection, collectionConfig);
+    console.log("📄 Collection Format YAML:");
+    console.log(collectionYaml);
+    console.log("");
+    // Generate table format YAML
+    const tableConfig = {
+        useTableTerminology: true,
+        entityType: 'table',
+        schemaPath: "../.yaml_schemas/table.schema.json"
+    };
+    const tableYaml = collectionToYaml(collection, tableConfig);
+    console.log("📄 Table Format YAML:");
+    console.log(tableYaml);
+}
+/**
+ * Example 3: Load and process YAML files with mixed terminologies
+ */
+export async function processYamlFiles(baseDir) {
+    console.log("📂 Processing YAML files with terminology support...");
+    const yamlLoader = createYamlLoader(baseDir);
+    // Load all YAML files from collections directory
+    const collectionsResult = await yamlLoader.loadDirectoryYamls("collections");
+    console.log(`📊 Collections Summary:`, collectionsResult.summary);
+    // Load all YAML files from tables directory
+    const tablesResult = await yamlLoader.loadDirectoryYamls("tables");
+    console.log(`📊 Tables Summary:`, tablesResult.summary);
+    // Process each file and show terminology detection
+    console.log("\\n🔍 File Analysis:");
+    [...collectionsResult.collections, ...tablesResult.collections].forEach(file => {
+        const terminology = file.originalTerminology;
+        const hasColumns = usesTableTerminology(file.data);
+        console.log(`  ${file.filePath}: ${terminology} format (uses table terminology: ${hasColumns})`);
+    });
+}
+/**
+ * Example 4: Migrate between terminologies
+ */
+export async function migrateTerminology(baseDir) {
+    console.log("🔄 Migrating between terminologies...");
+    const yamlLoader = createYamlLoader(baseDir);
+    // Migrate collections to table format
+    console.log("\\n📤 Migrating collections to table format...");
+    const collectionToTableResult = await yamlLoader.migrateTerminology("collections", "migrated/tables", true // to table terminology
+    );
+    console.log(`✅ Migration complete: ${collectionToTableResult.migrated} migrated, ${collectionToTableResult.skipped} skipped`);
+    if (collectionToTableResult.errors.length > 0) {
+        console.log(`❌ Errors:`, collectionToTableResult.errors);
+    }
+    // Migrate tables to collection format
+    console.log("\\n📤 Migrating tables to collection format...");
+    const tableToCollectionResult = await yamlLoader.migrateTerminology("tables", "migrated/collections", false // to collection terminology
+    );
+    console.log(`✅ Migration complete: ${tableToCollectionResult.migrated} migrated, ${tableToCollectionResult.skipped} skipped`);
+    if (tableToCollectionResult.errors.length > 0) {
+        console.log(`❌ Errors:`, tableToCollectionResult.errors);
+    }
+}
+/**
+ * Example 5: Validate terminology consistency
+ */
+export async function validateTerminology(baseDir) {
+    console.log("🔍 Validating terminology consistency...");
+    const yamlLoader = createYamlLoader(baseDir);
+    // Validate collections directory
+    const collectionsValidation = await yamlLoader.validateTerminologyConsistency("collections");
+    console.log("\\n📂 Collections Directory:");
+    console.log(`  Consistent: ${collectionsValidation.isConsistent}`);
+    console.log(`  Summary:`, collectionsValidation.summary);
+    if (collectionsValidation.issues.length > 0) {
+        console.log(`  Issues:`);
+        collectionsValidation.issues.forEach(issue => {
+            console.log(`    ${issue.severity.toUpperCase()}: ${issue.file} - ${issue.issue}`);
+        });
+    }
+    // Validate tables directory
+    const tablesValidation = await yamlLoader.validateTerminologyConsistency("tables");
+    console.log("\\n📂 Tables Directory:");
+    console.log(`  Consistent: ${tablesValidation.isConsistent}`);
+    console.log(`  Summary:`, tablesValidation.summary);
+    if (tablesValidation.issues.length > 0) {
+        console.log(`  Issues:`);
+        tablesValidation.issues.forEach(issue => {
+            console.log(`    ${issue.severity.toUpperCase()}: ${issue.file} - ${issue.issue}`);
+        });
+    }
+}
+/**
+ * Example 6: Import configuration with terminology support
+ */
+export async function importConfigurationExample(appwriteFolderPath) {
+    console.log("📥 Import configuration with terminology support...");
+    const yamlImportIntegration = new YamlImportIntegration(appwriteFolderPath);
+    // Initialize YAML import system
+    await yamlImportIntegration.initialize();
+    // Create example import configurations for both formats
+    console.log("\\n📝 Creating import configuration templates...");
+    // Collection format import config
+    await yamlImportIntegration.createFromTemplate("Users", "users.json", false, // collection terminology
+    "users-collection-import.yaml");
+    // Table format import config
+    await yamlImportIntegration.createFromTemplate("Users", "users.json", true, // table terminology
+    "users-table-import.yaml");
+    // Get statistics
+    const stats = await yamlImportIntegration.getStatistics();
+    console.log("\\n📊 Import Configuration Statistics:");
+    console.log(`  Total configurations: ${stats.totalConfigurations}`);
+    console.log(`  Collections with configs: ${stats.collectionsWithConfigs}`);
+    console.log(`  Total attribute mappings: ${stats.totalAttributeMappings}`);
+    console.log(`  Total relationship mappings: ${stats.totalRelationshipMappings}`);
+}
+/**
+ * Example 7: Manual terminology conversion
+ */
+export function manualTerminologyConversion() {
+    console.log("🔧 Manual terminology conversion example...");
+    // Sample YAML data with collection terminology
+    const collectionData = {
+        name: "Product",
+        id: "product",
+        attributes: [
+            {
+                key: "name",
+                type: "string",
+                required: true,
+                relatedCollection: "Categories"
+            }
+        ],
+        indexes: [
+            {
+                key: "name_index",
+                type: "key",
+                attributes: ["name"]
+            }
+        ]
+    };
+    console.log("\\n📝 Original (Collection format):");
+    console.log(JSON.stringify(collectionData, null, 2));
+    // Convert to table terminology
+    const tableData = convertTerminology(collectionData, true);
+    console.log("\\n🔄 Converted to Table format:");
+    console.log(JSON.stringify(tableData, null, 2));
+    // Convert back to collection terminology
+    const normalizedData = normalizeYamlData(tableData);
+    console.log("\\n↩️  Normalized back to Collection format:");
+    console.log(JSON.stringify(normalizedData, null, 2));
+    // Terminology detection
+    console.log("\\n🔍 Terminology Detection:");
+    console.log(`  Original uses table terminology: ${usesTableTerminology(collectionData)}`);
+    console.log(`  Converted uses table terminology: ${usesTableTerminology(tableData)}`);
+    console.log(`  Normalized uses table terminology: ${usesTableTerminology(normalizedData)}`);
+}
+/**
+ * Main example runner
+ */
+export async function runYamlTerminologyExamples(outputDir) {
+    console.log("🎯 Running YAML Terminology Examples\\n");
+    try {
+        // Example collection for demonstrations
+        const exampleCollectionInput = {
+            name: "Product",
+            $id: "product",
+            enabled: true,
+            documentSecurity: false,
+            $permissions: [],
+            attributes: [
+                {
+                    key: "name",
+                    type: "string",
+                    required: true,
+                    size: 255
+                },
+                {
+                    key: "price",
+                    type: "double",
+                    required: true,
+                    min: 0
+                },
+                {
+                    key: "categoryId",
+                    type: "relationship",
+                    relationType: "manyToOne",
+                    relatedCollection: "Categories",
+                    twoWay: false,
+                    onDelete: "setNull",
+                    required: false
+                }
+            ],
+            indexes: [
+                {
+                    key: "name_index",
+                    type: "key",
+                    attributes: ["name"]
+                }
+            ],
+            importDefs: []
+        };
+        const exampleCollection = CollectionCreateSchema.parse(exampleCollectionInput);
+        // Run examples
+        await generateTemplateExamples(outputDir);
+        console.log("\\n" + "=".repeat(60) + "\\n");
+        convertCollectionFormats(exampleCollection);
+        console.log("\\n" + "=".repeat(60) + "\\n");
+        await processYamlFiles(outputDir);
+        console.log("\\n" + "=".repeat(60) + "\\n");
+        await migrateTerminology(outputDir);
+        console.log("\\n" + "=".repeat(60) + "\\n");
+        await validateTerminology(outputDir);
+        console.log("\\n" + "=".repeat(60) + "\\n");
+        await importConfigurationExample(outputDir);
+        console.log("\\n" + "=".repeat(60) + "\\n");
+        manualTerminologyConversion();
+        console.log("\\n🎉 All examples completed successfully!");
+    }
+    catch (error) {
+        console.error("❌ Error running examples:", error);
+        throw error;
+    }
+}
+// Note: Functions are already exported above with their declarations

package/dist/functions/deployments.d.ts

@@ -0,0 +1,4 @@
+import { Client, type Models } from "node-appwrite";
+import { type AppwriteFunction } from "@njdamstra/appwrite-utils";
+export declare const deployFunction: (client: Client, functionId: string, codePath: string, activate?: boolean, entrypoint?: string, commands?: string, ignored?: string[]) => Promise<Models.Deployment>;
+export declare const deployLocalFunction: (client: Client, functionName: string, functionConfig: AppwriteFunction, functionPath?: string) => Promise<Models.Deployment>;

package/dist/functions/deployments.js

@@ -0,0 +1,146 @@
+import { Client, Functions, Runtime } from "node-appwrite";
+import { InputFile } from "node-appwrite/file";
+import { create as createTarball } from "tar";
+import { join, relative } from "node:path";
+import fs from "node:fs";
+import { platform } from "node:os";
+import {} from "@njdamstra/appwrite-utils";
+import chalk from "chalk";
+import cliProgress from "cli-progress";
+import { execSync } from "child_process";
+import { createFunction, getFunction, updateFunction, updateFunctionSpecifications, } from "./methods.js";
+import ignore from "ignore";
+import { MessageFormatter } from "../shared/messageFormatter.js";
+import { resolveFunctionDirectory, validateFunctionDirectory } from './pathResolution.js';
+export const deployFunction = async (client, functionId, codePath, activate = true, entrypoint = "index.js", commands = "npm install", ignored = [
+    "node_modules",
+    ".git",
+    ".vscode",
+    ".DS_Store",
+    "__pycache__",
+    ".venv",
+]) => {
+    const functions = new Functions(client);
+    MessageFormatter.processing("Preparing function deployment...", { prefix: "Deployment" });
+    // Convert ignored patterns to lowercase for case-insensitive comparison
+    const ignoredLower = ignored.map((pattern) => pattern.toLowerCase());
+    const tarPath = join(process.cwd(), `function-${functionId}.tar.gz`);
+    // Verify codePath exists and is a directory
+    if (!fs.existsSync(codePath)) {
+        throw new Error(`Function directory not found at ${codePath}`);
+    }
+    const stats = await fs.promises.stat(codePath);
+    if (!stats.isDirectory()) {
+        throw new Error(`${codePath} is not a directory`);
+    }
+    MessageFormatter.processing(`Creating tarball from ${codePath}`, { prefix: "Deployment" });
+    const progressBar = new cliProgress.SingleBar({
+        format: "Uploading |" +
+            chalk.cyan("{bar}") +
+            "| {percentage}% | {value}/{total} Chunks",
+        barCompleteChar: "█",
+        barIncompleteChar: "░",
+        hideCursor: true,
+    });
+    await createTarball({
+        gzip: true,
+        file: tarPath,
+        cwd: codePath,
+        filter: (path, stat) => {
+            const relativePath = relative(codePath, join(codePath, path)).toLowerCase();
+            // Skip if path matches any ignored pattern
+            if (ignoredLower.some((pattern) => relativePath.startsWith(pattern) ||
+                relativePath.includes(`/${pattern}`) ||
+                relativePath.includes(`\\${pattern}`))) {
+                MessageFormatter.debug(`Ignoring ${path}`, undefined, { prefix: "Deployment" });
+                return false;
+            }
+            return true;
+        },
+    }, ["."] // This now only includes contents of codePath since we set cwd to codePath
+    );
+    const fileBuffer = await fs.promises.readFile(tarPath);
+    const fileObject = InputFile.fromBuffer(new Uint8Array(fileBuffer), `function-${functionId}.tar.gz`);
+    try {
+        MessageFormatter.processing("Creating deployment...", { prefix: "Deployment" });
+        // Start with 1 as default total since we don't know the chunk size yet
+        progressBar.start(1, 0);
+        const functionResponse = await functions.createDeployment(functionId, fileObject, activate, entrypoint, commands, (progress) => {
+            const chunks = progress.chunksUploaded;
+            const total = progress.chunksTotal;
+            if (chunks !== undefined && total !== undefined) {
+                // First chunk, initialize the bar with correct total
+                if (chunks === 0) {
+                    progressBar.start(total || 100, 0);
+                }
+                else {
+                    progressBar.update(chunks);
+                    // Check if upload is complete
+                    if (chunks === total) {
+                        progressBar.update(total);
+                        progressBar.stop();
+                        MessageFormatter.success("Upload complete!", { prefix: "Deployment" });
+                    }
+                }
+            }
+        });
+        // Ensure progress bar completes even if callback never fired
+        if (progressBar.getProgress() === 0) {
+            progressBar.update(1);
+            progressBar.stop();
+        }
+        await fs.promises.unlink(tarPath);
+        return functionResponse;
+    }
+    catch (error) {
+        progressBar.stop();
+        MessageFormatter.error("Deployment failed", error instanceof Error ? error : undefined, { prefix: "Deployment" });
+        throw error;
+    }
+};
+export const deployLocalFunction = async (client, functionName, functionConfig, functionPath) => {
+    let functionExists = true;
+    let functionThatExists;
+    try {
+        functionThatExists = await getFunction(client, functionConfig.$id);
+    }
+    catch (error) {
+        functionExists = false;
+    }
+    const configDirPath = process.cwd(); // TODO: This should be passed from caller
+    const resolvedPath = resolveFunctionDirectory(functionName, configDirPath, functionConfig.dirPath, functionPath);
+    if (!validateFunctionDirectory(resolvedPath)) {
+        throw new Error(`Function directory is invalid or missing required files: ${resolvedPath}`);
+    }
+    if (functionConfig.predeployCommands?.length) {
+        MessageFormatter.processing("Executing predeploy commands...", { prefix: "Deployment" });
+        const isWindows = platform() === "win32";
+        for (const command of functionConfig.predeployCommands) {
+            try {
+                MessageFormatter.debug(`Executing: ${command}`, undefined, { prefix: "Deployment" });
+                execSync(command, {
+                    cwd: resolvedPath,
+                    stdio: "inherit",
+                    shell: isWindows ? "cmd.exe" : "/bin/sh",
+                    windowsHide: true,
+                });
+            }
+            catch (error) {
+                MessageFormatter.error(`Failed to execute predeploy command: ${command}`, error instanceof Error ? error : undefined, { prefix: "Deployment" });
+                throw new Error(``);
+            }
+        }
+    }
+    // Only create function if it doesn't exist
+    if (!functionExists) {
+        await createFunction(client, functionConfig);
+    }
+    else {
+        MessageFormatter.processing("Updating function...", { prefix: "Deployment" });
+        await updateFunction(client, functionConfig);
+    }
+    const deployPath = functionConfig.deployDir
+        ? join(resolvedPath, functionConfig.deployDir)
+        : resolvedPath;
+    return deployFunction(client, functionConfig.$id, deployPath, true, functionConfig.entrypoint, functionConfig.commands, functionConfig.ignore);
+};

package/dist/functions/fnConfigDiscovery.d.ts

@@ -0,0 +1,3 @@
+import { type AppwriteFunction } from '@njdamstra/appwrite-utils';
+export declare function discoverFnConfigs(startDir: string): AppwriteFunction[];
+export declare function mergeDiscoveredFunctions(central?: AppwriteFunction[], discovered?: AppwriteFunction[]): AppwriteFunction[];

package/dist/functions/fnConfigDiscovery.js

@@ -0,0 +1,108 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import yaml from 'js-yaml';
+import { homedir } from 'node:os';
+import { AppwriteFunctionSchema } from '@njdamstra/appwrite-utils';
+import { shouldIgnoreDirectory } from '../utils/directoryUtils.js';
+import { MessageFormatter } from '../shared/messageFormatter.js';
+function findGitRoot(startDir) {
+    let dir = path.resolve(startDir);
+    while (dir !== path.parse(dir).root) {
+        if (fs.existsSync(path.join(dir, '.git')))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return path.resolve(startDir);
+}
+function expandTilde(p) {
+    if (!p)
+        return p;
+    if (p === '~' || p.startsWith('~/'))
+        return p.replace(/^~(?=$|\/|\\)/, homedir());
+    return p;
+}
+export function discoverFnConfigs(startDir) {
+    const root = findGitRoot(startDir);
+    const results = [];
+    const visit = (dir, depth = 0) => {
+        if (depth > 5)
+            return; // cap depth
+        const base = path.basename(dir);
+        if (shouldIgnoreDirectory(base))
+            return;
+        let entries = [];
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        // Check for .fnconfig.yaml / .fnconfig.yml
+        for (const fname of ['.fnconfig.yaml', '.fnconfig.yml']) {
+            const cfgPath = path.join(dir, fname);
+            if (fs.existsSync(cfgPath)) {
+                try {
+                    const raw = fs.readFileSync(cfgPath, 'utf8');
+                    const data = yaml.load(raw);
+                    const parsed = AppwriteFunctionSchema.parse({
+                        $id: data.id || data.$id,
+                        name: data.name,
+                        runtime: data.runtime,
+                        execute: data.execute || [],
+                        events: data.events || [],
+                        schedule: data.schedule,
+                        timeout: data.timeout,
+                        enabled: data.enabled,
+                        logging: data.logging,
+                        entrypoint: data.entrypoint,
+                        commands: data.commands,
+                        scopes: data.scopes,
+                        installationId: data.installationId,
+                        providerRepositoryId: data.providerRepositoryId,
+                        providerBranch: data.providerBranch,
+                        providerSilentMode: data.providerSilentMode,
+                        providerRootDirectory: data.providerRootDirectory,
+                        templateRepository: data.templateRepository,
+                        templateOwner: data.templateOwner,
+                        templateRootDirectory: data.templateRootDirectory,
+                        templateVersion: data.templateVersion,
+                        specification: data.specification,
+                        dirPath: data.dirPath,
+                        predeployCommands: data.predeployCommands,
+                        deployDir: data.deployDir,
+                        ignore: data.ignore,
+                    });
+                    // Resolve dirPath relative to the config file directory
+                    let dirPath = parsed.dirPath || '.';
+                    dirPath = expandTilde(dirPath);
+                    if (!path.isAbsolute(dirPath))
+                        dirPath = path.resolve(path.dirname(cfgPath), dirPath);
+                    const merged = { ...parsed, dirPath };
+                    results.push(merged);
+                }
+                catch (e) {
+                    MessageFormatter.warning(`Failed to parse ${cfgPath}: ${e instanceof Error ? e.message : String(e)}`, { prefix: 'Functions' });
+                }
+            }
+        }
+        for (const entry of entries) {
+            if (entry.isDirectory())
+                visit(path.join(dir, entry.name), depth + 1);
+        }
+    };
+    visit(root, 0);
+    return results;
+}
+export function mergeDiscoveredFunctions(central = [], discovered = []) {
+    const map = new Map();
+    for (const f of central)
+        if (f?.$id)
+            map.set(f.$id, f);
+    for (const f of discovered)
+        if (f?.$id)
+            map.set(f.$id, f); // discovered overrides
+    return Array.from(map.values());
+}