@njdamstra/appwrite-utils-cli 1.8.9 → 1.10.0

package/dist/utils/constantsGenerator.js

@@ -1,321 +0,0 @@
-import fs from "fs/promises";
-import path from "path";
-import {} from "@njdamstra/appwrite-utils";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-export class ConstantsGenerator {
-    config;
-    constants;
-    constructor(config) {
-        this.config = config;
-        this.constants = this.extractConstants();
-    }
-    extractConstants() {
-        const constants = {
-            databases: {},
-            collections: {},
-            buckets: {},
-            functions: {}
-        };
-        // Extract database IDs
-        this.config.databases?.forEach(db => {
-            if (db.$id) {
-                const key = this.toConstantName(db.name || db.$id);
-                constants.databases[key] = db.$id;
-            }
-        });
-        // Extract collection IDs
-        this.config.collections?.forEach(collection => {
-            if (collection.$id) {
-                const key = this.toConstantName(collection.name || collection.$id);
-                constants.collections[key] = collection.$id;
-            }
-        });
-        // Extract bucket IDs
-        this.config.buckets?.forEach(bucket => {
-            if (bucket.$id) {
-                const key = this.toConstantName(bucket.name || bucket.$id);
-                constants.buckets[key] = bucket.$id;
-            }
-        });
-        // Extract function IDs
-        this.config.functions?.forEach(func => {
-            if (func.$id) {
-                const key = this.toConstantName(func.name || func.$id);
-                constants.functions[key] = func.$id;
-            }
-        });
-        return constants;
-    }
-    toConstantName(name) {
-        return name
-            .replace(/[^a-zA-Z0-9]/g, '_')
-            .replace(/_+/g, '_')
-            .replace(/^_|_$/g, '')
-            .toUpperCase();
-    }
-    toCamelCase(name) {
-        return name
-            .toLowerCase()
-            .replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-    }
-    toSnakeCase(name) {
-        return name.toLowerCase();
-    }
-    generateTypeScript(constantsOverride) {
-        const { databases, collections, buckets, functions } = constantsOverride || this.constants;
-        return `// Auto-generated Appwrite constants
-// Generated on ${new Date().toISOString()}
-
-export const DATABASE_IDS = {
-${Object.entries(databases).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
-} as const;
-
-export const COLLECTION_IDS = {
-${Object.entries(collections).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
-} as const;
-
-export const BUCKET_IDS = {
-${Object.entries(buckets).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
-} as const;
-
-export const FUNCTION_IDS = {
-${Object.entries(functions).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
-} as const;
-
-// Type helpers
-export type DatabaseId = typeof DATABASE_IDS[keyof typeof DATABASE_IDS];
-export type CollectionId = typeof COLLECTION_IDS[keyof typeof COLLECTION_IDS];
-export type BucketId = typeof BUCKET_IDS[keyof typeof BUCKET_IDS];
-export type FunctionId = typeof FUNCTION_IDS[keyof typeof FUNCTION_IDS];
-
-// Helper objects for runtime use
-export const ALL_DATABASE_IDS = Object.values(DATABASE_IDS);
-export const ALL_COLLECTION_IDS = Object.values(COLLECTION_IDS);
-export const ALL_BUCKET_IDS = Object.values(BUCKET_IDS);
-export const ALL_FUNCTION_IDS = Object.values(FUNCTION_IDS);
-`;
-    }
-    generateJavaScript(constantsOverride) {
-        const { databases, collections, buckets, functions } = constantsOverride || this.constants;
-        return `// Auto-generated Appwrite constants
-// Generated on ${new Date().toISOString()}
-
-export const DATABASE_IDS = {
-${Object.entries(databases).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
-};
-
-export const COLLECTION_IDS = {
-${Object.entries(collections).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
-};
-
-export const BUCKET_IDS = {
-${Object.entries(buckets).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
-};
-
-export const FUNCTION_IDS = {
-${Object.entries(functions).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
-};
-
-// Helper arrays for runtime use
-export const ALL_DATABASE_IDS = Object.values(DATABASE_IDS);
-export const ALL_COLLECTION_IDS = Object.values(COLLECTION_IDS);
-export const ALL_BUCKET_IDS = Object.values(BUCKET_IDS);
-export const ALL_FUNCTION_IDS = Object.values(FUNCTION_IDS);
-`;
-    }
-    generatePython(constantsOverride) {
-        const { databases, collections, buckets, functions } = constantsOverride || this.constants;
-        return `# Auto-generated Appwrite constants
-# Generated on ${new Date().toISOString()}
-
-class DatabaseIds:
-    """Database ID constants"""
-${Object.entries(databases).map(([key, value]) => `    ${key} = "${value}"`).join('\n')}
-
-class CollectionIds:
-    """Collection ID constants"""
-${Object.entries(collections).map(([key, value]) => `    ${key} = "${value}"`).join('\n')}
-
-class BucketIds:
-    """Bucket ID constants"""
-${Object.entries(buckets).map(([key, value]) => `    ${key} = "${value}"`).join('\n')}
-
-class FunctionIds:
-    """Function ID constants"""
-${Object.entries(functions).map(([key, value]) => `    ${key} = "${value}"`).join('\n')}
-
-# Helper dictionaries for runtime use
-DATABASE_ID_MAP = {
-${Object.entries(databases).map(([key, value]) => `    "${this.toSnakeCase(key)}": "${value}"`).join(',\n')}
-}
-
-COLLECTION_ID_MAP = {
-${Object.entries(collections).map(([key, value]) => `    "${this.toSnakeCase(key)}": "${value}"`).join(',\n')}
-}
-
-BUCKET_ID_MAP = {
-${Object.entries(buckets).map(([key, value]) => `    "${this.toSnakeCase(key)}": "${value}"`).join(',\n')}
-}
-
-FUNCTION_ID_MAP = {
-${Object.entries(functions).map(([key, value]) => `    "${this.toSnakeCase(key)}": "${value}"`).join(',\n')}
-}
-`;
-    }
-    generatePHP(constantsOverride) {
-        const { databases, collections, buckets, functions } = constantsOverride || this.constants;
-        return `<?php
-// Auto-generated Appwrite constants
-// Generated on ${new Date().toISOString()}
-
-class AppwriteConstants {
-    
-    const DATABASE_IDS = [
-${Object.entries(databases).map(([key, value]) => `        '${key}' => '${value}'`).join(',\n')}
-    ];
-    
-    const COLLECTION_IDS = [
-${Object.entries(collections).map(([key, value]) => `        '${key}' => '${value}'`).join(',\n')}
-    ];
-    
-    const BUCKET_IDS = [
-${Object.entries(buckets).map(([key, value]) => `        '${key}' => '${value}'`).join(',\n')}
-    ];
-    
-    const FUNCTION_IDS = [
-${Object.entries(functions).map(([key, value]) => `        '${key}' => '${value}'`).join(',\n')}
-    ];
-    
-    /**
-     * Get all database IDs as array
-     */
-    public static function getAllDatabaseIds(): array {
-        return array_values(self::DATABASE_IDS);
-    }
-    
-    /**
-     * Get all collection IDs as array
-     */
-    public static function getAllCollectionIds(): array {
-        return array_values(self::COLLECTION_IDS);
-    }
-    
-    /**
-     * Get all bucket IDs as array
-     */
-    public static function getAllBucketIds(): array {
-        return array_values(self::BUCKET_IDS);
-    }
-    
-    /**
-     * Get all function IDs as array
-     */
-    public static function getAllFunctionIds(): array {
-        return array_values(self::FUNCTION_IDS);
-    }
-}
-`;
-    }
-    generateDart(constantsOverride) {
-        const { databases, collections, buckets, functions } = constantsOverride || this.constants;
-        return `// Auto-generated Appwrite constants
-// Generated on ${new Date().toISOString()}
-
-class AppwriteConstants {
-  
-  static const Map<String, String> databaseIds = {
-${Object.entries(databases).map(([key, value]) => `    '${this.toCamelCase(key)}': '${value}'`).join(',\n')}
-  };
-  
-  static const Map<String, String> collectionIds = {
-${Object.entries(collections).map(([key, value]) => `    '${this.toCamelCase(key)}': '${value}'`).join(',\n')}
-  };
-  
-  static const Map<String, String> bucketIds = {
-${Object.entries(buckets).map(([key, value]) => `    '${this.toCamelCase(key)}': '${value}'`).join(',\n')}
-  };
-  
-  static const Map<String, String> functionIds = {
-${Object.entries(functions).map(([key, value]) => `    '${this.toCamelCase(key)}': '${value}'`).join(',\n')}
-  };
-  
-  // Helper getters for individual IDs
-${Object.entries(databases).map(([key, value]) => `  static String get ${this.toCamelCase(key)}DatabaseId => '${value}';`).join('\n')}
-  
-${Object.entries(collections).map(([key, value]) => `  static String get ${this.toCamelCase(key)}CollectionId => '${value}';`).join('\n')}
-  
-${Object.entries(buckets).map(([key, value]) => `  static String get ${this.toCamelCase(key)}BucketId => '${value}';`).join('\n')}
-  
-${Object.entries(functions).map(([key, value]) => `  static String get ${this.toCamelCase(key)}FunctionId => '${value}';`).join('\n')}
-}
-`;
-    }
-    generateJSON(constantsOverride) {
-        const c = constantsOverride || this.constants;
-        return JSON.stringify({
-            meta: {
-                generated: new Date().toISOString(),
-                generator: "@njdamstra/appwrite-utils-cli"
-            },
-            databases: c.databases,
-            collections: c.collections,
-            buckets: c.buckets,
-            functions: c.functions
-        }, null, 2);
-    }
-    generateEnv(constantsOverride) {
-        const { databases, collections, buckets, functions } = constantsOverride || this.constants;
-        const lines = [
-            "# Auto-generated Appwrite constants",
-            `# Generated on ${new Date().toISOString()}`,
-            "",
-            "# Database IDs",
-            ...Object.entries(databases).map(([key, value]) => `DATABASE_${key}=${value}`),
-            "",
-            "# Collection IDs",
-            ...Object.entries(collections).map(([key, value]) => `COLLECTION_${key}=${value}`),
-            "",
-            "# Bucket IDs",
-            ...Object.entries(buckets).map(([key, value]) => `BUCKET_${key}=${value}`),
-            "",
-            "# Function IDs",
-            ...Object.entries(functions).map(([key, value]) => `FUNCTION_${key}=${value}`)
-        ];
-        return lines.join('\n');
-    }
-    async generateFiles(languages, outputDir, include) {
-        await fs.mkdir(outputDir, { recursive: true });
-        const filterConstants = () => {
-            if (!include)
-                return this.constants;
-            return {
-                databases: include.databases === false ? {} : this.constants.databases,
-                collections: include.collections === false ? {} : this.constants.collections,
-                buckets: include.buckets === false ? {} : this.constants.buckets,
-                functions: include.functions === false ? {} : this.constants.functions,
-            };
-        };
-        const subset = filterConstants();
-        const generators = {
-            typescript: () => ({ content: this.generateTypeScript(subset), filename: "appwrite-constants.ts" }),
-            javascript: () => ({ content: this.generateJavaScript(subset), filename: "appwrite-constants.js" }),
-            python: () => ({ content: this.generatePython(subset), filename: "appwrite_constants.py" }),
-            php: () => ({ content: this.generatePHP(subset), filename: "AppwriteConstants.php" }),
-            dart: () => ({ content: this.generateDart(subset), filename: "appwrite_constants.dart" }),
-            json: () => ({ content: this.generateJSON(subset), filename: "appwrite-constants.json" }),
-            env: () => ({ content: this.generateEnv(subset), filename: ".env.appwrite" })
-        };
-        for (const language of languages) {
-            const generator = generators[language];
-            if (generator) {
-                const { content, filename } = generator();
-                const filePath = path.join(outputDir, filename);
-                await fs.writeFile(filePath, content, 'utf-8');
-                MessageFormatter.success(`Generated ${language} constants: ${filePath}`, { prefix: "Constants" });
-            }
-            else {
-                MessageFormatter.error(`Unsupported language: ${language}`, undefined, { prefix: "Constants" });
-            }
-        }
-    }
-}

package/dist/utils/dataConverters.d.ts

@@ -1,46 +0,0 @@
-import { type AttributeMappings } from "@njdamstra/appwrite-utils";
-/**
- * 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 declare const deepAnyToString: (data: any) => any;
-/**
- * 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 declare const deepConvert: <T>(data: any, convertFn: (value: any) => T) => any;
-/**
- * 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 declare const convertObjectBySchema: (obj: Record<string, any>, schema: Record<string, (value: any) => any>) => Record<string, any>;
-/**
- * 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 declare const convertObjectByAttributeMappings: (obj: Record<string, any>, attributeMappings: AttributeMappings) => Record<string, any>;
-/**
- * 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 declare const immutableConvert: <T>(data: any, convertFn: (value: any) => T) => T;
-/**
- * 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 declare const validateString: (value: string, pattern: RegExp) => string | null;

package/dist/utils/dataConverters.js

@@ -1,139 +0,0 @@
-import { converterFunctions } from "@njdamstra/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/directoryUtils.d.ts

@@ -1,22 +0,0 @@
-/**
- * Directory utility functions for filtering and managing directory traversal
- */
-/**
- * List of directories that should be ignored during recursive searches
- * Includes common build outputs, dependencies, caches, and system folders
- */
-export declare const IGNORED_DIRECTORIES: string[];
-/**
- * Determines if a directory should be ignored during recursive file operations
- *
- * @param dirName - The name of the directory to check
- * @returns true if the directory should be ignored, false otherwise
- *
- * @remarks
- * A directory is ignored if:
- * - It matches one of the entries in IGNORED_DIRECTORIES
- * - It starts with '.git' prefix
- * - It starts with 'node_modules' prefix
- * - It starts with '.' (hidden directory) except for '.appwrite'
- */
-export declare const shouldIgnoreDirectory: (dirName: string) => boolean;

package/dist/utils/directoryUtils.js

@@ -1,59 +0,0 @@
-/**
- * Directory utility functions for filtering and managing directory traversal
- */
-/**
- * List of directories that should be ignored during recursive searches
- * Includes common build outputs, dependencies, caches, and system folders
- */
-export const IGNORED_DIRECTORIES = [
-    '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'
-];
-/**
- * Determines if a directory should be ignored during recursive file operations
- *
- * @param dirName - The name of the directory to check
- * @returns true if the directory should be ignored, false otherwise
- *
- * @remarks
- * A directory is ignored if:
- * - It matches one of the entries in IGNORED_DIRECTORIES
- * - It starts with '.git' prefix
- * - It starts with 'node_modules' prefix
- * - It starts with '.' (hidden directory) except for '.appwrite'
- */
-export const shouldIgnoreDirectory = (dirName) => {
-    return IGNORED_DIRECTORIES.includes(dirName) ||
-        dirName.startsWith('.git') ||
-        dirName.startsWith('node_modules') ||
-        (dirName.startsWith('.') && dirName !== '.appwrite');
-};

package/dist/utils/getClientFromConfig.d.ts

@@ -1,39 +0,0 @@
-import { type AppwriteConfig } from "@njdamstra/appwrite-utils";
-import { Client } from "node-appwrite";
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
-/**
- * Enhanced client creation from config with session authentication support
- * @deprecated Use getAdapterFromConfig for dual API support with session auth
- */
-export declare const getClientFromConfig: (config: AppwriteConfig, sessionCookie?: string) => Client | undefined;
-/**
- * Enhanced client creation with session authentication support
- * Priority: explicit session > session from prefs > API key
- */
-export declare const getClientWithAuth: (endpoint: string, project: string, key?: string, sessionCookie?: string) => Client;
-/**
- * Legacy function - returns basic Client
- * @deprecated Use getClientWithAuth for session support or createDatabaseAdapter for dual API support
- */
-export declare const getClient: (endpoint: string, project: string, key: string) => Client;
-/**
- * Modern adapter-based client creation with dual API support and session authentication
- * Returns both adapter and legacy client for compatibility
- */
-export declare const getAdapterFromConfig: (config: AppwriteConfig, forceRefresh?: boolean, sessionCookie?: string) => Promise<{
-    adapter: DatabaseAdapter;
-    client: Client;
-    apiMode: "legacy" | "tablesdb";
-}>;
-/**
- * Create adapter from individual parameters with session authentication support
- */
-export declare const getAdapter: (endpoint: string, project: string, key?: string, apiMode?: "auto" | "legacy" | "tablesdb", sessionCookie?: string) => Promise<{
-    adapter: DatabaseAdapter;
-    client: Client;
-    apiMode: "legacy" | "tablesdb";
-}>;
-/**
- * Check if session authentication is available for a project
- */
-export declare const checkSessionAuth: (endpoint: string, project: string) => boolean;