@njdamstra/appwrite-utils-cli 1.8.9 → 1.10.0

package/src/utils/configDiscovery.ts

@@ -1,557 +0,0 @@
-import path from "path";
-import fs from "fs";
-import {
-  CollectionCreateSchema,
-  type CollectionCreate,
-  type Collection
-} from "@njdamstra/appwrite-utils";
-import { register } from "tsx/esm/api";
-import { pathToFileURL } from "node:url";
-import yaml from "js-yaml";
-import { z } from "zod";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-import { shouldIgnoreDirectory } from "./directoryUtils.js";
-import { resolveCollectionsDir, resolveTablesDir } from "./pathResolvers.js";
-import { findYamlConfig } from "../config/yamlConfig.js";
-
-/**
- * Recursively searches for TypeScript configuration files (appwriteConfig.ts)
- * @param dir The directory to start the search from
- * @param depth Current search depth for recursion limiting
- * @returns Path to the config file or null if not found
- */
-export const findAppwriteConfigTS = (dir: string, depth: number = 0): string | null => {
-  // Limit search depth to prevent infinite recursion
-  if (depth > 10) {
-    return null;
-  }
-
-  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") {
-        return path.join(dir, entry.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
-  }
-
-  return null;
-};
-
-/**
- * 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 directory path where the config was found, suitable for passing to loadConfig()
- */
-export const findAppwriteConfig = (dir: string): string | null => {
-  // 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;
-};
-
-/**
- * Recursively searches for the functions directory
- * @param dir The directory to start searching from
- * @param depth Current search depth for recursion limiting
- * @returns Path to the functions directory or null if not found
- */
-export const findFunctionsDir = (dir: string, depth: number = 0): string | null => {
-  // Limit search depth to prevent infinite recursion
-  if (depth > 5) {
-    return null;
-  }
-
-  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;
-    }
-  } 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(),
-      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(),
-      encrypt: z.boolean().optional(),
-      format: 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([])
-});
-
-type YamlCollection = z.infer<typeof YamlCollectionSchema>;
-
-// YAML Table Schema - Supports table-specific terminology
-const YamlTableSchema = z.object({
-  name: z.string(),
-  id: z.string().optional(),
-  rowSecurity: z.boolean().default(false), // Tables use rowSecurity
-  enabled: z.boolean().default(true),
-  permissions: z.array(
-    z.object({
-      permission: z.string(),
-      target: z.string()
-    })
-  ).optional().default([]),
-  columns: z.array( // Tables use columns terminology
-    z.object({
-      key: z.string(),
-      type: z.string(),
-      size: z.number().optional(),
-      required: z.boolean().default(false),
-      array: z.boolean().optional(),
-      encrypt: z.boolean().optional(), // Tables support encrypt property
-      default: z.any().optional(),
-      min: z.number().optional(),
-      max: z.number().optional(),
-      elements: z.array(z.string()).optional(),
-      relatedTable: z.string().optional(), // Tables use relatedTable
-      relationType: z.string().optional(),
-      twoWay: z.boolean().optional(),
-      twoWayKey: z.string().optional(),
-      onDelete: z.string().optional(),
-      side: z.string().optional(),
-      format: z.string().optional()
-    })
-  ).optional().default([]),
-  indexes: z.array(
-    z.object({
-      key: z.string(),
-      type: z.string(),
-      columns: z.array(z.string()), // Tables use columns in indexes
-      orders: z.array(z.string()).optional()
-    })
-  ).optional().default([]),
-  importDefs: z.array(z.any()).optional().default([])
-});
-
-type YamlTable = z.infer<typeof YamlTableSchema>;
-
-/**
- * Loads a YAML collection file and converts it to CollectionCreate format
- * @param filePath Path to the YAML collection file
- * @returns CollectionCreate object or null if loading fails
- */
-export const loadYamlCollection = (filePath: string): CollectionCreate | null => {
-  try {
-    const fileContent = fs.readFileSync(filePath, "utf8");
-    const yamlData = yaml.load(fileContent) as unknown;
-    const parsedCollection = YamlCollectionSchema.parse(yamlData);
-
-    // Convert YAML collection to CollectionCreate format
-    const collectionInput: CollectionCreate = {
-      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 as any,
-        target: p.target
-      })),
-      attributes: parsedCollection.attributes.map(attr => ({
-        key: attr.key,
-        type: attr.type as any,
-        size: attr.size,
-        required: attr.required,
-        array: attr.array,
-        xdefault: attr.default,
-        min: attr.min,
-        max: attr.max,
-        elements: attr.elements,
-        relatedCollection: attr.relatedCollection,
-        relationType: attr.relationType as any,
-        twoWay: attr.twoWay,
-        twoWayKey: attr.twoWayKey,
-        onDelete: attr.onDelete as any,
-        side: attr.side as any,
-        encrypt: (attr as any).encrypt,
-        format: (attr as any).format
-      })),
-      indexes: parsedCollection.indexes.map(idx => ({
-        key: idx.key,
-        type: idx.type as any,
-        attributes: idx.attributes,
-        orders: idx.orders as any
-      })),
-      importDefs: parsedCollection.importDefs && Array.isArray(parsedCollection.importDefs) && parsedCollection.importDefs.length > 0 ? parsedCollection.importDefs : []
-    };
-
-    const collection = CollectionCreateSchema.parse(collectionInput);
-
-    return collection;
-  } catch (error) {
-    MessageFormatter.error(`Error loading YAML collection from ${filePath}`, error as Error, { prefix: "Config" });
-    return null;
-  }
-};
-
-/**
- * Loads a YAML table file and converts it to CollectionCreate format
- * @param filePath Path to the YAML table file
- * @returns CollectionCreate object or null if loading fails
- */
-export const loadYamlTable = (filePath: string): CollectionCreate | null => {
-  try {
-    const fileContent = fs.readFileSync(filePath, "utf8");
-    const yamlData = yaml.load(fileContent) as unknown;
-
-    // Use the new table-specific schema
-    const parsedTable = YamlTableSchema.parse(yamlData);
-
-    // Convert YAML table to CollectionCreate format (internal representation)
-    const table: CollectionCreate = {
-      name: parsedTable.name,
-      $id: (yamlData as any).tableId || parsedTable.id || parsedTable.name.toLowerCase().replace(/\s+/g, '_'),
-      documentSecurity: parsedTable.rowSecurity, // Convert rowSecurity to documentSecurity
-      enabled: parsedTable.enabled,
-      $permissions: parsedTable.permissions.map(p => ({
-        permission: p.permission as any,
-        target: p.target
-      })),
-      attributes: parsedTable.columns.map(col => ({ // Convert columns to attributes
-        key: col.key,
-        type: col.type as any,
-        size: col.size,
-        required: col.required,
-        array: col.array,
-        xdefault: col.default,
-        min: col.min,
-        max: col.max,
-        elements: col.elements,
-        relatedCollection: col.relatedTable, // Convert relatedTable to relatedCollection
-        relationType: col.relationType as any,
-        twoWay: col.twoWay,
-        twoWayKey: col.twoWayKey,
-        onDelete: col.onDelete as any,
-        side: col.side as any,
-        encrypt: col.encrypt,
-        format: col.format
-      })),
-      indexes: parsedTable.indexes.map(idx => ({
-        key: idx.key,
-        type: idx.type as any,
-        attributes: idx.columns, // Convert columns to attributes
-        orders: idx.orders as any
-      })),
-      importDefs: parsedTable.importDefs || []
-    };
-
-    return table;
-  } catch (error) {
-    MessageFormatter.error(`Error loading YAML table from ${filePath}`, error as Error, { prefix: "Config" });
-    return null;
-  }
-};
-
-/**
- * Result of discovering collections from a directory
- */
-export interface CollectionDiscoveryResult {
-  collections: CollectionCreate[];
-  loadedNames: Set<string>;
-  conflicts: Array<{ name: string; source1: string; source2: string }>;
-}
-
-/**
- * Discovers and loads collections from a collections/ directory
- * @param collectionsDir Path to the collections directory
- * @returns Discovery result with loaded collections and metadata
- */
-export const discoverCollections = async (collectionsDir: string): Promise<CollectionDiscoveryResult> => {
-  const collections: CollectionCreate[] = [];
-  const loadedNames = new Set<string>();
-  const conflicts: Array<{ name: string; source1: string; source2: string }> = [];
-
-  if (!fs.existsSync(collectionsDir)) {
-    return { collections, loadedNames, conflicts };
-  }
-
-  const unregister = register(); // Register tsx for collections
-
-  try {
-    const collectionFiles = fs.readdirSync(collectionsDir);
-    MessageFormatter.success(`Loading from collections/ directory: ${collectionFiles.length} files found`, { prefix: "Config" });
-
-    for (const file of collectionFiles) {
-      if (file === "index.ts") {
-        continue;
-      }
-      const filePath = path.join(collectionsDir, file);
-      let collection: CollectionCreate | null = null;
-
-      // Handle YAML collections
-      if (file.endsWith('.yaml') || file.endsWith('.yml')) {
-        collection = loadYamlCollection(filePath);
-      }
-
-      // Handle TypeScript collections
-      else if (file.endsWith('.ts')) {
-        const fileUrl = pathToFileURL(filePath).href;
-        const collectionModule = (await import(fileUrl));
-        const importedCollection: Collection | undefined = collectionModule.default?.default || collectionModule.default || collectionModule;
-        if (importedCollection) {
-          collection = importedCollection as CollectionCreate;
-          // Ensure importDefs are properly loaded
-          if (collectionModule.importDefs || collection.importDefs) {
-            collection.importDefs = collectionModule.importDefs || collection.importDefs;
-          }
-        }
-      }
-
-      if (collection) {
-        const collectionName = collection.name || collection.$id || file;
-        loadedNames.add(collectionName);
-        collections.push(collection);
-      }
-    }
-  } finally {
-    unregister(); // Unregister tsx when done
-  }
-
-  return { collections, loadedNames, conflicts };
-};
-
-/**
- * Result of discovering tables from a directory
- */
-export interface TableDiscoveryResult {
-  tables: CollectionCreate[];
-  loadedNames: Set<string>;
-  conflicts: Array<{ name: string; source1: string; source2: string }>;
-}
-
-/**
- * Discovers and loads tables from a tables/ directory
- * @param tablesDir Path to the tables directory
- * @param existingNames Set of already-loaded collection names to check for conflicts
- * @returns Discovery result with loaded tables and metadata
- */
-export const discoverTables = async (
-  tablesDir: string,
-  existingNames: Set<string> = new Set()
-): Promise<TableDiscoveryResult> => {
-  const tables: CollectionCreate[] = [];
-  const loadedNames = new Set<string>();
-  const conflicts: Array<{ name: string; source1: string; source2: string }> = [];
-
-  if (!fs.existsSync(tablesDir)) {
-    return { tables, loadedNames, conflicts };
-  }
-
-  const unregister = register(); // Register tsx for tables
-
-  try {
-    const tableFiles = fs.readdirSync(tablesDir);
-    MessageFormatter.success(`Loading from tables/ directory: ${tableFiles.length} files found`, { prefix: "Config" });
-
-    for (const file of tableFiles) {
-      if (file === "index.ts") {
-        continue;
-      }
-      const filePath = path.join(tablesDir, file);
-      let table: CollectionCreate | null = null;
-
-      // Handle YAML tables
-      if (file.endsWith('.yaml') || file.endsWith('.yml')) {
-        table = loadYamlTable(filePath);
-      }
-
-      // Handle TypeScript tables
-      else if (file.endsWith('.ts')) {
-        const fileUrl = pathToFileURL(filePath).href;
-        const tableModule = (await import(fileUrl));
-        const importedTable: CollectionCreate = tableModule.default?.default || tableModule.default || tableModule;
-        if (importedTable) {
-          table = importedTable;
-          // Ensure importDefs are properly loaded
-          if (tableModule.importDefs || table.importDefs) {
-            table.importDefs = tableModule.importDefs || table.importDefs;
-          }
-        }
-      }
-
-      if (table) {
-        const tableName = table.name || (table as any).tableId || table.$id || file;
-
-        // Check for naming conflicts with existing collections
-        if (existingNames.has(tableName)) {
-          conflicts.push({
-            name: tableName,
-            source1: "collections/",
-            source2: "tables/"
-          });
-          MessageFormatter.warning(`Skipping duplicate '${tableName}' from tables/ (collections/ takes priority)`, { prefix: "Config" });
-        } else {
-          loadedNames.add(tableName);
-          // Mark as coming from tables directory
-          (table as any)._isFromTablesDir = true;
-          tables.push(table);
-        }
-      }
-    }
-  } finally {
-    unregister(); // Unregister tsx when done
-  }
-
-  return { tables, loadedNames, conflicts };
-};
-
-/**
- * Discovers and loads collections/tables from legacy single directory structure
- * @param configFileDir Directory containing the config file
- * @param dirName Directory name to search for ('collections' or 'tables')
- * @returns Array of discovered collections/tables
- */
-export const discoverLegacyDirectory = async (
-  configFileDir: string,
-  dirName: 'collections' | 'tables'
-): Promise<CollectionCreate[]> => {
-  const legacyDir = path.join(configFileDir, dirName);
-  const items: CollectionCreate[] = [];
-
-  if (!fs.existsSync(legacyDir)) {
-    return items;
-  }
-
-  MessageFormatter.info(`Using legacy single directory: ${dirName}/`, { prefix: "Config" });
-
-  const unregister = register(); // Register tsx for legacy collections
-
-  try {
-    const collectionFiles = fs.readdirSync(legacyDir);
-
-    for (const file of collectionFiles) {
-      if (file === "index.ts") {
-        continue;
-      }
-      const filePath = path.join(legacyDir, file);
-
-      // Handle YAML collections
-      if (file.endsWith('.yaml') || file.endsWith('.yml')) {
-        const collection = loadYamlCollection(filePath);
-        if (collection) {
-          if (dirName === 'tables') {
-            // Mark as coming from tables directory
-            const table = {
-              ...collection,
-              _isFromTablesDir: true,
-              tableId: collection.$id || collection.name.toLowerCase().replace(/\s+/g, '_')
-            } as CollectionCreate;
-            items.push(table);
-          } else {
-            items.push(collection);
-          }
-        }
-        continue;
-      }
-
-      // Handle TypeScript collections
-      if (file.endsWith('.ts')) {
-        const fileUrl = pathToFileURL(filePath).href;
-        const collectionModule = (await import(fileUrl));
-        const collection: Collection | undefined = 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 (dirName === 'tables') {
-            // Mark as coming from tables directory
-            const table = {
-              ...collection,
-              _isFromTablesDir: true,
-              tableId: collection.$id || collection.name.toLowerCase().replace(/\s+/g, '_')
-            };
-            items.push(table as CollectionCreate);
-          } else {
-            items.push(collection as CollectionCreate);
-          }
-        }
-      }
-    }
-  } finally {
-    unregister(); // Unregister tsx when done
-  }
-
-  return items;
-};