appwrite-utils-cli 0.10.86 → 1.0.2

package/dist/utils/dataConverters.js

@@ -0,0 +1,139 @@
+import { converterFunctions } from "appwrite-utils";
+import { cloneDeep, isPlainObject } from "es-toolkit";
+/**
+ * Deeply converts all properties of an object (or array) to strings.
+ * @param data The input data to convert.
+ * @returns The data with all its properties converted to strings.
+ */
+export const deepAnyToString = (data) => {
+    if (Array.isArray(data)) {
+        return data.map((item) => deepAnyToString(item));
+    }
+    else if (isPlainObject(data)) {
+        return Object.keys(data).reduce((acc, key) => {
+            acc[key] = deepAnyToString(data[key]);
+            return acc;
+        }, {});
+    }
+    else {
+        return converterFunctions.anyToString(data);
+    }
+};
+/**
+ * Performs a deep conversion of all values in a nested structure to the specified type.
+ * Uses a conversion function like anyToString, anyToNumber, etc.
+ * @param data The data to convert.
+ * @param convertFn The conversion function to apply.
+ * @returns The converted data.
+ */
+export const deepConvert = (data, convertFn) => {
+    if (Array.isArray(data)) {
+        return data.map((item) => deepConvert(item, convertFn));
+    }
+    else if (isPlainObject(data)) {
+        return Object.keys(data).reduce((acc, key) => {
+            acc[key] = deepConvert(data[key], convertFn);
+            return acc;
+        }, {});
+    }
+    else {
+        return convertFn(data);
+    }
+};
+/**
+ * Converts an entire object's properties to different types based on a provided schema.
+ * @param obj The object to convert.
+ * @param schema A mapping of object keys to conversion functions.
+ * @returns The converted object.
+ */
+export const convertObjectBySchema = (obj, schema) => {
+    return Object.keys(obj).reduce((acc, key) => {
+        const convertFn = schema[key];
+        acc[key] = convertFn ? convertFn(obj[key]) : obj[key];
+        return acc;
+    }, {});
+};
+/**
+ * Converts the keys of an object based on a provided attributeMappings.
+ * Each key in the object is checked against attributeMappings; if a matching entry is found,
+ * the key is renamed to the targetKey specified in attributeMappings.
+ *
+ * @param obj The object to convert.
+ * @param attributeMappings The attributeMappings defining how keys in the object should be converted.
+ * @returns The converted object with keys renamed according to attributeMappings.
+ */
+export const convertObjectByAttributeMappings = (obj, attributeMappings) => {
+    const result = {};
+    // Correctly handle [any] notation by mapping or aggregating over all elements or keys
+    const resolveValue = (obj, path) => {
+        const parts = path.split(".");
+        let current = obj;
+        for (let i = 0; i < parts.length; i++) {
+            if (parts[i] === "[any]") {
+                if (Array.isArray(current)) {
+                    // If current is an array, apply resolution to each item
+                    return current.map((item) => resolveValue(item, parts.slice(i + 1).join(".")));
+                }
+                else if (typeof current === "object" && current !== null) {
+                    // If current is an object, aggregate values from all keys
+                    return Object.values(current).map((value) => resolveValue(value, parts.slice(i + 1).join(".")));
+                }
+            }
+            else {
+                current = current[parts[i]];
+                if (current === undefined)
+                    return undefined;
+            }
+        }
+        return current;
+    };
+    for (const mapping of attributeMappings) {
+        if (mapping.valueToSet !== undefined) {
+            result[mapping.targetKey] = mapping.valueToSet;
+        }
+        else if (Array.isArray(mapping.oldKeys)) {
+            // Collect and flatten values from multiple oldKeys
+            const values = mapping.oldKeys
+                .map((oldKey) => resolveValue(obj, oldKey))
+                .flat(Infinity);
+            if (values.length > 0) {
+                result[mapping.targetKey] = values.filter((value) => value !== undefined);
+            }
+            else {
+                result[mapping.targetKey] = null;
+            }
+        }
+        else if (mapping.oldKey) {
+            // Resolve single oldKey
+            const value = resolveValue(obj, mapping.oldKey);
+            if (value !== undefined) {
+                result[mapping.targetKey] = Array.isArray(value)
+                    ? value.flat(Infinity)
+                    : value;
+            }
+            else {
+                result[mapping.targetKey] = value ? value : null;
+            }
+        }
+    }
+    return result;
+};
+/**
+ * Ensures data conversion without mutating the original input.
+ * @param data The data to convert.
+ * @param convertFn The conversion function to apply.
+ * @returns The converted data.
+ */
+export const immutableConvert = (data, convertFn) => {
+    const clonedData = cloneDeep(data);
+    return convertFn(clonedData);
+};
+/**
+ * Validates a string against a regular expression and returns the string if valid, or null.
+ * @param value The string to validate.
+ * @param pattern The regex pattern to validate against.
+ * @returns The original string if valid, otherwise null.
+ */
+export const validateString = (value, pattern) => {
+    return pattern.test(value) ? value : null;
+};

package/dist/utils/loadConfigs.d.ts

@@ -1,14 +1,25 @@
 import { type AppwriteConfig } from "appwrite-utils";
 /**
- * Recursively searches for a file named 'appwriteConfig.ts' starting from the given directory.
+ * Recursively searches for configuration files starting from the given directory.
+ * Priority: 1) YAML configs in .appwrite directories, 2) appwriteConfig.ts files in subdirectories
  * @param dir The directory to start the search from.
- * @returns The path to the file if found, or null if not found.
+ * @returns The directory path where the config was found, suitable for passing to loadConfig().
  */
 export declare const findAppwriteConfig: (dir: string) => string | null;
+/**
+ * Loads the Appwrite configuration and returns both config and the path where it was found.
+ * @param configDir The directory to search for config files.
+ * @returns Object containing the config and the actual path where it was found.
+ */
+export declare const loadConfigWithPath: (configDir: string) => Promise<{
+    config: AppwriteConfig;
+    actualConfigPath: string;
+}>;
 /**
  * Loads the Appwrite configuration and all collection configurations from a specified directory.
- * @param configDir The directory containing the appwriteConfig.ts and collections folder.
+ * Supports both YAML and TypeScript config formats with backward compatibility.
+ * @param configDir The directory containing the config file and collections folder.
  * @returns The loaded Appwrite configuration including collections.
  */
 export declare const loadConfig: (configDir: string) => Promise<AppwriteConfig>;
-export declare const findFunctionsDir: (dir: string) => string | null;
+export declare const findFunctionsDir: (dir: string, depth?: number) => string | null;

package/dist/utils/loadConfigs.js

@@ -4,84 +4,412 @@ import {} from "appwrite-utils";
 import { register } from "tsx/esm/api"; // Import the register function
 import { pathToFileURL } from "node:url";
 import chalk from "chalk";
+import { findYamlConfig, loadYamlConfig } from "../config/yamlConfig.js";
+import yaml from "js-yaml";
+import { z } from "zod";
 /**
- * Recursively searches for a file named 'appwriteConfig.ts' starting from the given directory.
+ * Recursively searches for configuration files starting from the given directory.
+ * Priority: 1) YAML configs in .appwrite directories, 2) appwriteConfig.ts files in subdirectories
  * @param dir The directory to start the search from.
- * @returns The path to the file if found, or null if not found.
+ * @returns The directory path where the config was found, suitable for passing to loadConfig().
  */
 export const findAppwriteConfig = (dir) => {
-    if (dir === "node_modules") {
+    // First try to find YAML config (already searches recursively for .appwrite dirs)
+    const yamlConfig = findYamlConfig(dir);
+    if (yamlConfig) {
+        // Return the directory containing the config file
+        return path.dirname(yamlConfig);
+    }
+    // Fall back to TypeScript config search
+    const tsConfigPath = findAppwriteConfigTS(dir);
+    if (tsConfigPath) {
+        return path.dirname(tsConfigPath);
+    }
+    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 findAppwriteConfigTS = (dir, depth = 0) => {
+    // Limit search depth to prevent infinite recursion
+    if (depth > 10) {
         return null;
     }
-    const files = fs.readdirSync(dir, { withFileTypes: true });
-    for (const file of files) {
-        if (file.isDirectory() && file.name !== "node_modules") {
-            const result = findAppwriteConfig(path.join(dir, file.name));
-            if (result)
-                return result;
+    if (shouldIgnoreDirectory(path.basename(dir))) {
+        return null;
+    }
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        // First check current directory for appwriteConfig.ts
+        for (const entry of entries) {
+            if (entry.isFile() && entry.name === "appwriteConfig.ts") {
+                console.log(`Found appwriteConfig.ts at: ${path.join(dir, entry.name)}`);
+                return path.join(dir, entry.name);
+            }
         }
-        else if (file.name === "appwriteConfig.ts") {
-            return path.join(dir, file.name);
+        // Then search subdirectories
+        for (const entry of entries) {
+            if (entry.isDirectory() && !shouldIgnoreDirectory(entry.name)) {
+                const result = findAppwriteConfigTS(path.join(dir, entry.name), depth + 1);
+                if (result)
+                    return result;
+            }
         }
     }
+    catch (error) {
+        // Ignore directory access errors
+        console.log(`Error accessing directory ${dir}:`, error);
+    }
     return null;
 };
+/**
+ * Loads the Appwrite configuration and returns both config and the path where it was found.
+ * @param configDir The directory to search for config files.
+ * @returns Object containing the config and the actual path where it was found.
+ */
+export const loadConfigWithPath = async (configDir) => {
+    let config = null;
+    let actualConfigPath = null;
+    // Check if we're given the .appwrite directory directly
+    if (configDir.endsWith('.appwrite')) {
+        // Look for config files directly in this directory
+        const possibleYamlFiles = ['config.yaml', 'config.yml', 'appwriteConfig.yaml', 'appwriteConfig.yml'];
+        for (const fileName of possibleYamlFiles) {
+            const yamlPath = path.join(configDir, fileName);
+            if (fs.existsSync(yamlPath)) {
+                config = await loadYamlConfig(yamlPath);
+                actualConfigPath = yamlPath;
+                break;
+            }
+        }
+    }
+    else {
+        // Original logic: search for .appwrite directories
+        const yamlConfigPath = findYamlConfig(configDir);
+        if (yamlConfigPath) {
+            config = await loadYamlConfig(yamlConfigPath);
+            actualConfigPath = yamlConfigPath;
+        }
+    }
+    // Fall back to TypeScript config if YAML not found or failed to load
+    if (!config) {
+        const configPath = path.join(configDir, "appwriteConfig.ts");
+        // Only try to load TypeScript config if the file exists
+        if (fs.existsSync(configPath)) {
+            const unregister = register(); // Register tsx enhancement
+            try {
+                console.log(`Loading TypeScript config from: ${configPath}`);
+                const configUrl = pathToFileURL(configPath).href;
+                const configModule = (await import(configUrl));
+                config = configModule.default?.default || configModule.default || configModule;
+                if (!config) {
+                    throw new Error("Failed to load config");
+                }
+                actualConfigPath = configPath;
+            }
+            finally {
+                unregister(); // Unregister tsx when done
+            }
+        }
+    }
+    if (!config || !actualConfigPath) {
+        throw new Error("No valid configuration found");
+    }
+    // Determine collections directory based on actual config file location
+    let collectionsDir;
+    const configFileDir = path.dirname(actualConfigPath);
+    // Check if config is in .appwrite directory
+    if (configFileDir.endsWith('.appwrite')) {
+        collectionsDir = path.join(configFileDir, "collections");
+    }
+    else {
+        // Config is in root or other directory
+        collectionsDir = path.join(configFileDir, "collections");
+    }
+    // Load collections if they exist
+    if (fs.existsSync(collectionsDir)) {
+        const unregister = register(); // Register tsx for collections
+        try {
+            const collectionFiles = fs.readdirSync(collectionsDir);
+            config.collections = [];
+            for (const file of collectionFiles) {
+                if (file === "index.ts") {
+                    continue;
+                }
+                const filePath = path.join(collectionsDir, file);
+                // Handle YAML collections
+                if (file.endsWith('.yaml') || file.endsWith('.yml')) {
+                    const collection = loadYamlCollection(filePath);
+                    if (collection) {
+                        config.collections.push(collection);
+                    }
+                    continue;
+                }
+                // Handle TypeScript collections
+                if (file.endsWith('.ts')) {
+                    const fileUrl = pathToFileURL(filePath).href;
+                    const collectionModule = (await import(fileUrl));
+                    const collection = collectionModule.default?.default || collectionModule.default || collectionModule;
+                    if (collection) {
+                        // Ensure importDefs are properly loaded
+                        if (collectionModule.importDefs || collection.importDefs) {
+                            collection.importDefs = collectionModule.importDefs || collection.importDefs;
+                        }
+                        config.collections.push(collection);
+                    }
+                }
+            }
+        }
+        finally {
+            unregister(); // Unregister tsx when done
+        }
+    }
+    return { config, actualConfigPath };
+};
 /**
  * Loads the Appwrite configuration and all collection configurations from a specified directory.
- * @param configDir The directory containing the appwriteConfig.ts and collections folder.
+ * Supports both YAML and TypeScript config formats with backward compatibility.
+ * @param configDir The directory containing the config file and collections folder.
  * @returns The loaded Appwrite configuration including collections.
  */
 export const loadConfig = async (configDir) => {
-    const unregister = register(); // Register tsx enhancement
-    try {
+    let config = null;
+    let actualConfigPath = null;
+    // First try to find and load YAML config
+    const yamlConfigPath = findYamlConfig(configDir);
+    if (yamlConfigPath) {
+        console.log(`Loading YAML config from: ${yamlConfigPath}`);
+        config = await loadYamlConfig(yamlConfigPath);
+        actualConfigPath = yamlConfigPath;
+    }
+    // Fall back to TypeScript config if YAML not found or failed to load
+    if (!config) {
         const configPath = path.join(configDir, "appwriteConfig.ts");
-        console.log(`Loading config from: ${configPath}`);
-        const configUrl = pathToFileURL(configPath).href;
-        const configModule = (await import(configUrl));
-        const config = configModule.default?.default || configModule.default || configModule;
-        if (!config) {
-            throw new Error("Failed to load config");
-        }
-        const collectionsDir = path.join(configDir, "collections");
-        const collectionFiles = fs.readdirSync(collectionsDir);
-        config.collections = [];
-        for (const file of collectionFiles) {
-            if (file === "index.ts") {
-                continue;
+        // Only try to load TypeScript config if the file exists
+        if (fs.existsSync(configPath)) {
+            const unregister = register(); // Register tsx enhancement
+            try {
+                console.log(`Loading TypeScript config from: ${configPath}`);
+                const configUrl = pathToFileURL(configPath).href;
+                const configModule = (await import(configUrl));
+                config = configModule.default?.default || configModule.default || configModule;
+                if (!config) {
+                    throw new Error("Failed to load config");
+                }
+                actualConfigPath = configPath;
+            }
+            finally {
+                unregister(); // Unregister tsx when done
             }
-            const filePath = path.join(collectionsDir, file);
-            const fileUrl = pathToFileURL(filePath).href;
-            const collectionModule = (await import(fileUrl));
-            const collection = collectionModule.default?.default || collectionModule.default || collectionModule;
-            if (collection) {
-                // Ensure importDefs are properly loaded
-                if (collectionModule.importDefs || collection.importDefs) {
-                    collection.importDefs = collectionModule.importDefs || collection.importDefs;
+        }
+    }
+    if (!config) {
+        throw new Error("No valid configuration found");
+    }
+    // Determine collections directory based on actual config file location
+    let collectionsDir;
+    if (actualConfigPath) {
+        const configFileDir = path.dirname(actualConfigPath);
+        // Check if config is in .appwrite directory
+        if (configFileDir.endsWith('.appwrite')) {
+            collectionsDir = path.join(configFileDir, "collections");
+        }
+        else {
+            // Config is in root or other directory
+            collectionsDir = path.join(configFileDir, "collections");
+        }
+    }
+    else {
+        // Fallback to original behavior if no actual config path found
+        collectionsDir = path.join(configDir, "collections");
+    }
+    // Load collections if they exist
+    if (fs.existsSync(collectionsDir)) {
+        const unregister = register(); // Register tsx for collections
+        try {
+            const collectionFiles = fs.readdirSync(collectionsDir);
+            config.collections = [];
+            for (const file of collectionFiles) {
+                if (file === "index.ts") {
+                    continue;
+                }
+                const filePath = path.join(collectionsDir, file);
+                // Handle YAML collections
+                if (file.endsWith('.yaml') || file.endsWith('.yml')) {
+                    const collection = loadYamlCollection(filePath);
+                    if (collection) {
+                        config.collections.push(collection);
+                    }
+                    continue;
+                }
+                // Handle TypeScript collections
+                if (file.endsWith('.ts')) {
+                    const fileUrl = pathToFileURL(filePath).href;
+                    const collectionModule = (await import(fileUrl));
+                    const collection = collectionModule.default?.default || collectionModule.default || collectionModule;
+                    if (collection) {
+                        // Ensure importDefs are properly loaded
+                        if (collectionModule.importDefs || collection.importDefs) {
+                            collection.importDefs = collectionModule.importDefs || collection.importDefs;
+                        }
+                        config.collections.push(collection);
+                    }
                 }
-                config.collections.push(collection);
             }
         }
-        return config;
+        finally {
+            unregister(); // Unregister tsx when done
+        }
     }
-    finally {
-        unregister(); // Unregister tsx when done
+    else {
+        config.collections = config.collections || [];
     }
+    return config;
 };
-export const findFunctionsDir = (dir) => {
-    if (dir === "node_modules") {
+export const findFunctionsDir = (dir, depth = 0) => {
+    // Limit search depth to prevent infinite recursion
+    if (depth > 5) {
         return null;
     }
-    const files = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of files) {
-        if (!entry.isDirectory() || entry.name === "node_modules") {
-            continue;
-        }
-        if (entry.name === "functions") {
-            return path.join(dir, entry.name);
+    if (shouldIgnoreDirectory(path.basename(dir))) {
+        return null;
+    }
+    try {
+        const files = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of files) {
+            if (!entry.isDirectory() || shouldIgnoreDirectory(entry.name)) {
+                continue;
+            }
+            if (entry.name === "functions") {
+                return path.join(dir, entry.name);
+            }
+            const result = findFunctionsDir(path.join(dir, entry.name), depth + 1);
+            if (result)
+                return result;
         }
-        const result = findFunctionsDir(path.join(dir, entry.name));
-        if (result)
-            return result;
+    }
+    catch (error) {
+        // Ignore directory access errors
     }
     return null;
 };
+// YAML Collection Schema
+const YamlCollectionSchema = z.object({
+    name: z.string(),
+    id: z.string().optional(),
+    documentSecurity: z.boolean().default(false),
+    enabled: z.boolean().default(true),
+    permissions: z.array(z.object({
+        permission: z.string(),
+        target: z.string()
+    })).optional().default([]),
+    attributes: z.array(z.object({
+        key: z.string(),
+        type: z.string(),
+        size: z.number().optional(),
+        required: z.boolean().default(false),
+        array: z.boolean().optional(),
+        default: z.any().optional(),
+        description: z.string().optional(),
+        min: z.number().optional(),
+        max: z.number().optional(),
+        elements: z.array(z.string()).optional(),
+        relatedCollection: z.string().optional(),
+        relationType: z.string().optional(),
+        twoWay: z.boolean().optional(),
+        twoWayKey: z.string().optional(),
+        onDelete: z.string().optional(),
+        side: z.string().optional()
+    })).optional().default([]),
+    indexes: z.array(z.object({
+        key: z.string(),
+        type: z.string(),
+        attributes: z.array(z.string()),
+        orders: z.array(z.string()).optional()
+    })).optional().default([]),
+    importDefs: z.array(z.any()).optional().default([])
+});
+const loadYamlCollection = (filePath) => {
+    try {
+        const fileContent = fs.readFileSync(filePath, "utf8");
+        const yamlData = yaml.load(fileContent);
+        const parsedCollection = YamlCollectionSchema.parse(yamlData);
+        // Convert YAML collection to CollectionCreate format
+        const collection = {
+            name: parsedCollection.name,
+            $id: parsedCollection.id || parsedCollection.name.toLowerCase().replace(/\s+/g, '_'),
+            documentSecurity: parsedCollection.documentSecurity,
+            enabled: parsedCollection.enabled,
+            $permissions: parsedCollection.permissions.map(p => ({
+                permission: p.permission,
+                target: p.target
+            })),
+            attributes: parsedCollection.attributes.map(attr => ({
+                key: attr.key,
+                type: attr.type,
+                size: attr.size,
+                required: attr.required,
+                array: attr.array,
+                xdefault: attr.default,
+                description: attr.description,
+                min: attr.min,
+                max: attr.max,
+                elements: attr.elements,
+                relatedCollection: attr.relatedCollection,
+                relationType: attr.relationType,
+                twoWay: attr.twoWay,
+                twoWayKey: attr.twoWayKey,
+                onDelete: attr.onDelete,
+                side: attr.side
+            })),
+            indexes: parsedCollection.indexes.map(idx => ({
+                key: idx.key,
+                type: idx.type,
+                attributes: idx.attributes,
+                orders: idx.orders
+            })),
+            importDefs: parsedCollection.importDefs
+        };
+        return collection;
+    }
+    catch (error) {
+        console.error(`Error loading YAML collection from ${filePath}:`, error);
+        return null;
+    }
+};

package/dist/utils/schemaStrings.js

@@ -337,7 +337,8 @@ export class SchemaGenerator {
                     baseSchemaCode += ".nullish()";
                 }
                 break;
-            case "float":
+            case "double":
+            case "float": // Backward compatibility
                 baseSchemaCode = "z.number()";
                 if (finalAttribute.min !== undefined) {
                     baseSchemaCode += `.min(${finalAttribute.min}, "Minimum value of ${finalAttribute.min} not met")`;

package/dist/utils/setupFiles.d.ts

@@ -1,3 +1,4 @@
 export declare const customDefinitionsFile = "import type { ConverterFunctions, ValidationRules, AfterImportActions } from \"appwrite-utils\";\n\nexport const customConverterFunctions: ConverterFunctions = {\n  // Add your custom converter functions here\n}\nexport const customValidationRules: ValidationRules = {\n  // Add your custom validation rules here\n}\nexport const customAfterImportActions: AfterImportActions = {\n  // Add your custom after import actions here\n}";
 export declare const createEmptyCollection: (collectionName: string) => void;
-export declare const setupDirsFiles: (example?: boolean, currentDir?: string) => Promise<void>;
+export declare const generateYamlConfig: (currentDir?: string, useAppwriteDir?: boolean) => string;
+export declare const setupDirsFiles: (example?: boolean, currentDir?: string, useYaml?: boolean) => Promise<void>;