appwrite-cli 17.2.1 → 17.3.0

package/lib/commands/errors.ts

@@ -1,93 +0,0 @@
-/**
- * Error thrown when destructive changes are detected during push operations
- * and the force flag is not enabled.
- */
-export class DestructiveChangeError extends Error {
-  constructor(
-    message: string,
-    private metadata: {
-      changes: Array<{
-        type: string;
-        resource: string;
-        field: string;
-        oldValue?: unknown;
-        newValue?: unknown;
-      }>;
-      affectedResources: number;
-    },
-  ) {
-    super(message);
-    this.name = "DestructiveChangeError";
-    Error.captureStackTrace(this, DestructiveChangeError);
-  }
-
-  /**
-   * Get detailed metadata about the destructive changes
-   */
-  public getMetadata() {
-    return this.metadata;
-  }
-}
-
-/**
- * Error thrown when configuration validation fails
- */
-export class ConfigValidationError extends Error {
-  constructor(
-    message: string,
-    private validationErrors: Array<{
-      path: string;
-      message: string;
-    }>,
-  ) {
-    super(message);
-    this.name = "ConfigValidationError";
-    Error.captureStackTrace(this, ConfigValidationError);
-  }
-
-  /**
-   * Get detailed validation errors
-   */
-  public getValidationErrors() {
-    return this.validationErrors;
-  }
-}
-
-/**
- * Error thrown when a requested resource is not found
- */
-export class ResourceNotFoundError extends Error {
-  constructor(
-    message: string,
-    public resourceType: string,
-    public resourceId: string,
-  ) {
-    super(message);
-    this.name = "ResourceNotFoundError";
-    Error.captureStackTrace(this, ResourceNotFoundError);
-  }
-}
-
-/**
- * Error thrown when authentication fails or is missing
- */
-export class AuthenticationError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "AuthenticationError";
-    Error.captureStackTrace(this, AuthenticationError);
-  }
-}
-
-/**
- * Error thrown when project is not initialized
- */
-export class ProjectNotInitializedError extends Error {
-  constructor(
-    message: string = "Project configuration not found. Project must be initialized first.",
-  ) {
-    super(message);
-    this.name = "ProjectNotInitializedError";
-    Error.captureStackTrace(this, ProjectNotInitializedError);
-  }
-}

package/lib/commands/generate.ts

@@ -1,205 +0,0 @@
-import * as path from "path";
-import { Command } from "commander";
-import { ConfigType } from "./config.js";
-import { localConfig } from "../config.js";
-import { success, error, log, warn, actionRunner } from "../parser.js";
-import {
-  createGeneratorFromDetection,
-  createGenerator,
-  getSupportedLanguages,
-  LanguageDetector,
-  SupportedLanguage,
-} from "./generators/index.js";
-import { globalConfig } from "../config.js";
-import {
-  SDK_TITLE,
-  SDK_TITLE_LOWER,
-  EXECUTABLE_NAME,
-  DEFAULT_ENDPOINT,
-} from "../constants.js";
-import { detectImportExtension } from "../shared/typescript-type-utils.js";
-
-type ServerSideOverride = "auto" | "true" | "false";
-
-export interface GenerateCommandOptions {
-  output: string;
-  language?: string;
-  server?: ServerSideOverride;
-  appwriteImportSource?: string;
-  importExtension?: string;
-}
-
-const generateAction = async (
-  options: GenerateCommandOptions,
-): Promise<void> => {
-  const project = localConfig.getProject();
-
-  if (!project.projectId) {
-    error(
-      `No project found. Please run '${EXECUTABLE_NAME} init project' first.`,
-    );
-    process.exit(1);
-  }
-
-  // Determine the generator to use
-  let generator;
-  let detectedLanguage: string;
-
-  const serverSideOverride: ServerSideOverride = options.server ?? "auto";
-  if (!["auto", "true", "false"].includes(serverSideOverride)) {
-    error(`Invalid --server value: ${serverSideOverride}`);
-    process.exit(1);
-  }
-
-  if (options.language) {
-    // User explicitly specified a language
-    if (!LanguageDetector.isSupported(options.language)) {
-      const supported = getSupportedLanguages().join(", ");
-      error(
-        `Unsupported language: ${options.language}. Supported languages: ${supported}`,
-      );
-      process.exit(1);
-    }
-    generator = createGenerator(options.language as SupportedLanguage);
-    detectedLanguage = options.language;
-    log(`Using specified language: ${detectedLanguage}`);
-  } else {
-    // Auto-detect language
-    try {
-      const { generator: detectedGenerator, detection } =
-        createGeneratorFromDetection();
-      generator = detectedGenerator;
-      detectedLanguage = detection.language;
-
-      if (detection.confidence === "low") {
-        warn(
-          `Detected language '${detectedLanguage}' with low confidence (${detection.reason}). ` +
-            `Use --language to specify explicitly.`,
-        );
-      } else {
-        log(`Detected language: ${detectedLanguage} (${detection.reason})`);
-      }
-    } catch (err) {
-      const supported = getSupportedLanguages().join(", ");
-      const message = err instanceof Error ? err.message : String(err);
-      error(
-        `${message}\nUse --language to specify the target language. Supported: ${supported}`,
-      );
-      process.exit(1);
-    }
-  }
-
-  if (typeof generator.setServerSideOverride === "function") {
-    generator.setServerSideOverride(serverSideOverride);
-  }
-
-  const config: ConfigType = {
-    projectId: project.projectId,
-    projectName: project.projectName,
-    endpoint:
-      localConfig.getEndpoint() ||
-      globalConfig.getEndpoint() ||
-      DEFAULT_ENDPOINT,
-    tablesDB: localConfig.getTablesDBs(),
-    tables: localConfig.getTables(),
-    databases: localConfig.getDatabases(),
-    collections: localConfig.getCollections(),
-  };
-
-  const outputDir = options.output;
-  const absoluteOutputDir = path.isAbsolute(outputDir)
-    ? outputDir
-    : path.join(process.cwd(), outputDir);
-
-  log(
-    `Generating type-safe ${detectedLanguage} SDK to ${absoluteOutputDir}...`,
-  );
-
-  try {
-    const result = await generator.generate(config, {
-      appwriteImportSource: options.appwriteImportSource,
-      importExtension: options.importExtension,
-    });
-    await generator.writeFiles(absoluteOutputDir, result);
-
-    const generatedFiles = generator.getGeneratedFilePaths(result);
-    success(`Generated files:`);
-    for (const file of generatedFiles) {
-      console.log(`  - ${path.join(outputDir, file)}`);
-    }
-
-    // Show language-specific usage instructions
-    if (detectedLanguage === "typescript") {
-      const entities = config.tables?.length
-        ? config.tables
-        : config.collections;
-      const firstEntity = entities?.[0];
-      const dbId = firstEntity?.databaseId ?? "databaseId";
-      const tableName = firstEntity?.name ?? "tableName";
-      const importExt = options.importExtension ?? detectImportExtension();
-
-      console.log("");
-      log(`Import the generated SDK in your project:`);
-      console.log(
-        `  import { databases } from "./${outputDir}/${SDK_TITLE_LOWER}/index${importExt}";`,
-      );
-      console.log("");
-      log(`Configure your SDK constants:`);
-      console.log(
-        `  set values in ./${outputDir}/${SDK_TITLE_LOWER}/constants.ts`,
-      );
-      console.log("");
-      log(`Usage:`);
-      console.log(`  const mydb = databases.use(${JSON.stringify(dbId)});`);
-      console.log(
-        `  await mydb.use(${JSON.stringify(tableName)}).create({ ... });`,
-      );
-    }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    error(`Failed to generate SDK: ${message}`);
-    process.exit(1);
-  }
-};
-
-export const generate = new Command("generate")
-  .description(
-    `Generate a type-safe SDK from your ${SDK_TITLE} project configuration`,
-  )
-  .option(
-    "-o, --output <directory>",
-    "Output directory for generated files",
-    "generated",
-  )
-  .option(
-    "-l, --language <language>",
-    `Target language for SDK generation (supported: ${getSupportedLanguages().join(", ")})`,
-  )
-  .option(
-    "--server <mode>",
-    "Override server-side generation (auto|true|false)",
-    "auto",
-  )
-  .option(
-    "--appwrite-import-source <source>",
-    "Override Appwrite import source in generated files (e.g. node-appwrite, appwrite, @appwrite.io/console). Auto-detected from package.json/deno.json if not provided.",
-  )
-  .option(
-    "--import-extension <ext>",
-    'Override import file extension in generated files (.js for ESM, empty string for CJS). Auto-detected from package.json "type" field if not provided.',
-  )
-  .addHelpText(
-    "after",
-    `
-Example:
-  Import the generated SDK in your project:
-    import { databases } from "./generated/${SDK_TITLE_LOWER}/index${detectImportExtension()}";
-
-  Configure your SDK constants:
-    set values in ./generated/${SDK_TITLE_LOWER}/constants.ts
-
-  Usage:
-    const mydb = databases.use("databaseId");
-    await mydb.use("tableName").create({ ... });`,
-  )
-  .action(actionRunner(generateAction));

package/lib/commands/generators/base.ts

@@ -1,147 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { ConfigType } from "../config.js";
-import { SDK_TITLE_LOWER } from "../../constants.js";
-
-/**
- * Supported programming languages for SDK generation.
- * Add new languages here as they are implemented.
- */
-export type SupportedLanguage = "typescript";
-
-/**
- * Result of the generation process.
- * Each language generator should return named content fields with fixed output filenames
- * under `<output>/<sdk-title-lower>/`.
- *
- * - `dbContent` -> `databases.ts`
- * - `typesContent` -> `types.ts`
- * - `indexContent` -> `index.ts` (entrypoint to import `databases` and exported types)
- * - `constantsContent` -> `constants.ts`
- */
-export interface GenerateResult {
-  dbContent: string;
-  typesContent: string;
-  indexContent: string;
-  constantsContent: string;
-}
-
-/**
- * Options for overriding auto-detected generation settings.
- */
-export interface GenerateOptions {
-  /**
-   * Override the Appwrite import source used in generated files.
-   * Auto-detected from package.json/deno.json if not provided.
-   * Examples: "node-appwrite", "appwrite", "@appwrite.io/console"
-   */
-  appwriteImportSource?: string;
-  /**
-   * Override the import file extension used in generated files.
-   * Auto-detected from package.json "type" field / deno.json if not provided.
-   * Use ".js" for ESM projects or "" for CJS/unknown projects.
-   */
-  importExtension?: string;
-}
-
-/**
- * Base interface for all language-specific database generators.
- * Implement this interface to add support for new languages.
- */
-export interface IDatabasesGenerator {
-  /**
-   * The language this generator produces code for.
-   */
-  readonly language: SupportedLanguage;
-
-  /**
-   * File extension for the generated files (e.g., "ts", "py", "go").
-   */
-  readonly fileExtension: string;
-
-  /**
-   * Generate the SDK files from the configuration.
-   * @param config - The project configuration containing tables/collections
-   * @param options - Optional overrides for auto-detected settings (e.g. import source, extension)
-   * @returns Promise resolving to named file contents:
-   * `dbContent` (`databases.ts`), `typesContent` (`types.ts`),
-   * `indexContent` (`index.ts`), and `constantsContent` (`constants.ts`).
-   * Import your generated SDK from `index.ts` (or `index.js` after transpilation).
-   */
-  generate(
-    config: ConfigType,
-    options?: GenerateOptions,
-  ): Promise<GenerateResult>;
-
-  /**
-   * Write the generated files to disk.
-   * @param outputDir - The base output directory
-   * @param result - The generation result containing files to write
-   */
-  writeFiles(outputDir: string, result: GenerateResult): Promise<void>;
-
-  /**
-   * Get the list of generated file paths (relative to output directory).
-   * Used for displaying success messages.
-   * @param result - The generation result
-   */
-  getGeneratedFilePaths(result: GenerateResult): string[];
-
-  /**
-   * Optional method to override server-side generation behavior.
-   * @param override - The override value
-   */
-  setServerSideOverride?(override: "auto" | "true" | "false"): void;
-}
-
-/**
- * Abstract base class providing common functionality for database generators.
- * Extend this class to implement language-specific generators.
- */
-export abstract class BaseDatabasesGenerator implements IDatabasesGenerator {
-  abstract readonly language: SupportedLanguage;
-  abstract readonly fileExtension: string;
-
-  abstract generate(
-    config: ConfigType,
-    options?: GenerateOptions,
-  ): Promise<GenerateResult>;
-
-  async writeFiles(outputDir: string, result: GenerateResult): Promise<void> {
-    const sdkDir = path.join(outputDir, SDK_TITLE_LOWER);
-    if (!fs.existsSync(sdkDir)) {
-      fs.mkdirSync(sdkDir, { recursive: true });
-    }
-
-    const fileEntries: Array<[string, string]> = [
-      ["databases.ts", result.dbContent],
-      ["types.ts", result.typesContent],
-      ["index.ts", result.indexContent],
-      ["constants.ts", result.constantsContent],
-    ];
-
-    for (const [relativePath, content] of fileEntries) {
-      const filePath = path.join(sdkDir, relativePath);
-      const fileDir = path.dirname(filePath);
-
-      if (!fs.existsSync(fileDir)) {
-        fs.mkdirSync(fileDir, { recursive: true });
-      }
-
-      if (relativePath === "constants.ts" && fs.existsSync(filePath)) {
-        continue;
-      }
-
-      fs.writeFileSync(filePath, content, "utf-8");
-    }
-  }
-
-  getGeneratedFilePaths(_result: GenerateResult): string[] {
-    return [
-      path.join(SDK_TITLE_LOWER, "databases.ts"),
-      path.join(SDK_TITLE_LOWER, "types.ts"),
-      path.join(SDK_TITLE_LOWER, "index.ts"),
-      path.join(SDK_TITLE_LOWER, "constants.ts"),
-    ];
-  }
-}

package/lib/commands/generators/index.ts

@@ -1,88 +0,0 @@
-import { IDatabasesGenerator, SupportedLanguage } from "./base.js";
-import {
-  LanguageDetector,
-  LanguageDetectionResult,
-} from "./language-detector.js";
-import { TypeScriptDatabasesGenerator } from "./typescript/databases.js";
-
-export {
-  IDatabasesGenerator,
-  SupportedLanguage,
-  GenerateResult,
-  GenerateOptions,
-} from "./base.js";
-export {
-  LanguageDetector,
-  LanguageDetectionResult,
-} from "./language-detector.js";
-
-/**
- * Factory function type for creating database generators.
- */
-type GeneratorFactory = () => IDatabasesGenerator;
-
-/**
- * Registry of generator factories by language.
- * Add new language generators here as they are implemented.
- */
-const generatorRegistry: Record<SupportedLanguage, GeneratorFactory> = {
-  typescript: () => new TypeScriptDatabasesGenerator(),
-  // Future languages:
-  // python: () => new PythonDatabasesGenerator(),
-  // go: () => new GoDatabasesGenerator(),
-  // dart: () => new DartDatabasesGenerator(),
-};
-
-/**
- * Create a database generator for the specified language.
- * @param language - The target language
- * @returns The appropriate generator instance
- * @throws Error if the language is not supported
- */
-export function createGenerator(
-  language: SupportedLanguage,
-): IDatabasesGenerator {
-  const factory = generatorRegistry[language];
-  if (!factory) {
-    throw new Error(
-      `No generator available for language: ${language}. ` +
-        `Supported languages: ${Object.keys(generatorRegistry).join(", ")}`,
-    );
-  }
-  return factory();
-}
-
-/**
- * Create a database generator by auto-detecting the project language.
- * @param cwd - The working directory to detect language from (defaults to process.cwd())
- * @returns Object containing the generator and detection result
- * @throws Error if no supported language is detected
- */
-export function createGeneratorFromDetection(cwd?: string): {
-  generator: IDatabasesGenerator;
-  detection: LanguageDetectionResult;
-} {
-  const detector = new LanguageDetector(cwd);
-  const detection = detector.detect();
-
-  if (!detection) {
-    const supported = LanguageDetector.getSupportedLanguages().join(", ");
-    throw new Error(
-      `Could not detect project language. ` +
-        `Supported languages: ${supported}. ` +
-        `Please ensure your project has the appropriate configuration files (e.g., package.json for TypeScript).`,
-    );
-  }
-
-  return {
-    generator: createGenerator(detection.language),
-    detection,
-  };
-}
-
-/**
- * Get all supported languages.
- */
-export function getSupportedLanguages(): SupportedLanguage[] {
-  return Object.keys(generatorRegistry) as SupportedLanguage[];
-}

package/lib/commands/generators/language-detector.ts

@@ -1,163 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { SupportedLanguage } from "./base.js";
-
-/**
- * Language detection result with confidence level.
- */
-export interface LanguageDetectionResult {
-  language: SupportedLanguage;
-  confidence: "high" | "medium" | "low";
-  reason: string;
-}
-
-/**
- * Configuration for detecting a specific language.
- */
-interface LanguageConfig {
-  language: SupportedLanguage;
-  /** Files that indicate this language with high confidence */
-  primaryIndicators: string[];
-  /** Files that indicate this language with medium confidence */
-  secondaryIndicators: string[];
-  /** File extensions to scan for */
-  fileExtensions: string[];
-}
-
-/**
- * Language detection configurations.
- * Add new languages here as they are supported.
- */
-const languageConfigs: LanguageConfig[] = [
-  {
-    language: "typescript",
-    primaryIndicators: ["tsconfig.json", "package.json", "deno.json"],
-    secondaryIndicators: [
-      ".nvmrc",
-      "package-lock.json",
-      "yarn.lock",
-      "pnpm-lock.yaml",
-      "bun.lockb",
-    ],
-    fileExtensions: [".ts", ".tsx", ".js", ".jsx"],
-  },
-  // Future languages can be added here:
-  // {
-  //   language: "python",
-  //   primaryIndicators: ["requirements.txt", "pyproject.toml", "setup.py", "Pipfile"],
-  //   secondaryIndicators: [".python-version", "poetry.lock"],
-  //   fileExtensions: [".py"],
-  // },
-  // {
-  //   language: "go",
-  //   primaryIndicators: ["go.mod"],
-  //   secondaryIndicators: ["go.sum"],
-  //   fileExtensions: [".go"],
-  // },
-  // {
-  //   language: "dart",
-  //   primaryIndicators: ["pubspec.yaml"],
-  //   secondaryIndicators: ["pubspec.lock"],
-  //   fileExtensions: [".dart"],
-  // },
-];
-
-/**
- * Detects the programming language of a project based on its directory contents.
- */
-export class LanguageDetector {
-  private cwd: string;
-
-  constructor(cwd: string = process.cwd()) {
-    this.cwd = cwd;
-  }
-
-  /**
-   * Detect the primary language of the project.
-   * @returns The detected language and confidence level, or null if no supported language detected
-   */
-  detect(): LanguageDetectionResult | null {
-    for (const config of languageConfigs) {
-      const result = this.checkLanguage(config);
-      if (result) {
-        return result;
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * Check if a specific language is detected in the project.
-   */
-  private checkLanguage(
-    config: LanguageConfig,
-  ): LanguageDetectionResult | null {
-    // Check primary indicators first
-    for (const indicator of config.primaryIndicators) {
-      if (this.fileExists(indicator)) {
-        return {
-          language: config.language,
-          confidence: "high",
-          reason: `Found ${indicator}`,
-        };
-      }
-    }
-
-    // Check secondary indicators
-    for (const indicator of config.secondaryIndicators) {
-      if (this.fileExists(indicator)) {
-        return {
-          language: config.language,
-          confidence: "medium",
-          reason: `Found ${indicator}`,
-        };
-      }
-    }
-
-    // Check for file extensions in the current directory
-    const hasMatchingFiles = this.hasFilesWithExtensions(config.fileExtensions);
-    if (hasMatchingFiles) {
-      return {
-        language: config.language,
-        confidence: "low",
-        reason: `Found files with extensions: ${config.fileExtensions.join(", ")}`,
-      };
-    }
-
-    return null;
-  }
-
-  /**
-   * Check if a file exists in the project directory.
-   */
-  private fileExists(filename: string): boolean {
-    return fs.existsSync(path.resolve(this.cwd, filename));
-  }
-
-  /**
-   * Check if files with specific extensions exist in the current directory.
-   */
-  private hasFilesWithExtensions(extensions: string[]): boolean {
-    try {
-      const files = fs.readdirSync(this.cwd);
-      return files.some((file) => extensions.some((ext) => file.endsWith(ext)));
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Get all supported languages.
-   */
-  static getSupportedLanguages(): SupportedLanguage[] {
-    return languageConfigs.map((c) => c.language);
-  }
-
-  /**
-   * Check if a language is supported.
-   */
-  static isSupported(language: string): language is SupportedLanguage {
-    return languageConfigs.some((c) => c.language === language);
-  }
-}