@njdamstra/appwrite-utils-cli 1.8.9 → 1.10.0

package/src/utils/constantsGenerator.ts

@@ -1,369 +0,0 @@
-import fs from "fs/promises";
-import path from "path";
-import { type AppwriteConfig } from "@njdamstra/appwrite-utils";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-
-export type SupportedLanguage = 
-  | "typescript" 
-  | "javascript" 
-  | "python" 
-  | "php" 
-  | "dart" 
-  | "json" 
-  | "env";
-
-interface Constants {
-  databases: Record<string, string>;
-  collections: Record<string, string>;
-  buckets: Record<string, string>;
-  functions: Record<string, string>;
-}
-
-export class ConstantsGenerator {
-  private config: AppwriteConfig;
-  private constants: Constants;
-
-  constructor(config: AppwriteConfig) {
-    this.config = config;
-    this.constants = this.extractConstants();
-  }
-
-  private extractConstants(): Constants {
-    const constants: 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;
-  }
-
-  private toConstantName(name: string): string {
-    return name
-      .replace(/[^a-zA-Z0-9]/g, '_')
-      .replace(/_+/g, '_')
-      .replace(/^_|_$/g, '')
-      .toUpperCase();
-  }
-
-  private toCamelCase(name: string): string {
-    return name
-      .toLowerCase()
-      .replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-  }
-
-  private toSnakeCase(name: string): string {
-    return name.toLowerCase();
-  }
-
-  generateTypeScript(constantsOverride?: Constants): string {
-    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?: Constants): string {
-    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?: Constants): string {
-    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?: Constants): string {
-    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?: Constants): string {
-    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?: Constants): string {
-    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?: Constants): string {
-    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: SupportedLanguage[],
-    outputDir: string,
-    include?: { databases?: boolean; collections?: boolean; buckets?: boolean; functions?: boolean }
-  ): Promise<void> {
-    await fs.mkdir(outputDir, { recursive: true });
-
-    const filterConstants = (): Constants => {
-      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/src/utils/dataConverters.ts

@@ -1,159 +0,0 @@
-import { converterFunctions, type AttributeMappings } 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: any): any => {
-  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 as keyof typeof data]);
-      return acc;
-    }, {} as Record<string, any>);
-  } 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 = <T>(
-  data: any,
-  convertFn: (value: any) => T
-): any => {
-  if (Array.isArray(data)) {
-    return data.map((item) => deepConvert(item, convertFn));
-  } else if (isPlainObject(data)) {
-    return Object.keys(data).reduce((acc: Record<string, T>, key: string) => {
-      acc[key] = deepConvert(data[key as keyof typeof data], 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: Record<string, any>,
-  schema: Record<string, (value: any) => any>
-): Record<string, any> => {
-  return Object.keys(obj).reduce((acc: Record<string, any>, key: string) => {
-    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: Record<string, any>,
-  attributeMappings: AttributeMappings
-): Record<string, any> => {
-  const result: Record<string, any> = {};
-
-  // Correctly handle [any] notation by mapping or aggregating over all elements or keys
-  const resolveValue = (obj: Record<string, any>, path: string): any => {
-    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 = <T>(
-  data: any,
-  convertFn: (value: any) => T
-): T => {
-  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: string,
-  pattern: RegExp
-): string | null => {
-  return pattern.test(value) ? value : null;
-};

package/src/utils/directoryUtils.ts

@@ -1,61 +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: string): boolean => {
-  return IGNORED_DIRECTORIES.includes(dirName) ||
-         dirName.startsWith('.git') ||
-         dirName.startsWith('node_modules') ||
-         (dirName.startsWith('.') && dirName !== '.appwrite');
-};