buildx-cli 1.0.0 → 1.0.2

package/src/commands/sync.ts

@@ -1,64 +0,0 @@
-import { Command } from "commander";
-import chalk from "chalk";
-import ora from "ora";
-import fs from "fs-extra";
-import path from "path";
-import { configManager } from "../config/index";
-import { apiService } from "../services/api";
-
-export const syncCommand = new Command("sync")
-	.description("Sync schema and generate TypeScript types")
-	.requiredOption("-p, --project-id <project-id>", "Project ID to sync schema from")
-	.option("-o, --output <path>", "Output path for generated types", "./generated/types.ts")
-	.option("-u, --api-url <url>", "Custom API base URL")
-	.option("-f, --force", "Force overwrite existing files")
-	.action(async (options) => {
-		try {
-			// Check API configuration
-			if (!apiService.isConfigured()) {
-				console.error(chalk.red('❌ API not configured'));
-				console.log(chalk.yellow('Please configure your API endpoint and API key first:'));
-				console.log(chalk.cyan('  buildx config setup'));
-				process.exit(1);
-			}
-			// Check authentication
-			if (!configManager.isAuthenticated()) {
-				console.error(chalk.red("Error: Not authenticated"));
-				console.log(chalk.yellow("Run \"buildx login\" to authenticate first"));
-				process.exit(1);
-			}
-
-			const { projectId, output, apiUrl, force } = options;
-
-			// Set custom API URL if provided
-			if (apiUrl) {
-				apiService.setBaseUrl(apiUrl);
-			}
-
-			// Fetch schema
-			const spinner = ora("Fetching TypeScript types...").start();
-
-			try {
-				const typescriptCode = await apiService.getSchema(projectId);
-				spinner.succeed("TypeScript types fetched successfully");
-
-				// Ensure output directory exists
-				const outputDir = path.dirname(output);
-				await fs.ensureDir(outputDir);
-
-				// Write the TypeScript code directly to file
-				await fs.writeFile(output, typescriptCode, "utf8");
-
-				console.log(chalk.green("✓ Types generated at:"), output);
-				console.log(chalk.blue("File size:"), `${(typescriptCode.length / 1024).toFixed(2)} KB`);
-
-			} catch (error) {
-				spinner.fail("Failed to fetch TypeScript types");
-				throw error;
-			}
-
-		} catch (error) {
-			console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
-			process.exit(1);
-		}
-	}); 

package/src/config/index.ts

@@ -1,154 +0,0 @@
-import Conf from "conf";
-import { GlobalConfig, AuthConfig, ProjectsConfig, SyncConfig, ApiConfig } from "../types/index";
-
-export class ConfigManager {
-  private config: Conf<GlobalConfig>;
-
-  constructor() {
-    this.config = new Conf<GlobalConfig>({
-      projectName: "buildx-cli",
-      schema: {
-        api: {
-          type: "object",
-          properties: {
-            endpoint: { type: "string" },
-            apiKey: { type: "string" }
-          }
-        },
-        auth: {
-          type: "object",
-          properties: {
-            token: { type: "string" },
-            expiresAt: { type: "string" }
-          }
-        },
-        projects: {
-          type: "object",
-          properties: {
-            default: { type: "string" },
-            list: { type: "array" }
-          }
-        },
-        sync: {
-          type: "object",
-          properties: {
-            outputPath: { type: "string" }
-          }
-        }
-      },
-      defaults: {
-        sync: {
-          outputPath: "./generated/types.ts"
-        }
-      }
-    });
-  }
-
-  // API configuration methods
-  getApiConfig(): ApiConfig | undefined {
-    return this.config.get("api");
-  }
-
-  setApiConfig(api: ApiConfig): void {
-    this.config.set("api", api);
-  }
-
-  clearApiConfig(): void {
-    this.config.delete("api");
-  }
-
-  isApiConfigured(): boolean {
-    const api = this.getApiConfig();
-    return !!(api?.endpoint && api?.apiKey);
-  }
-
-  // Auth methods
-  getAuth(): AuthConfig | undefined {
-    return this.config.get("auth");
-  }
-
-  setAuth(auth: AuthConfig): void {
-    this.config.set("auth", auth);
-  }
-
-  clearAuth(): void {
-    this.config.delete("auth");
-  }
-
-  isAuthenticated(): boolean {
-    const auth = this.getAuth();
-    if (!auth || !auth.token) {
-      return false;
-    }
-
-    // Check if token is expired
-    if (auth.expiresAt) {
-      const expiresAt = new Date(auth.expiresAt);
-      if (expiresAt < new Date()) {
-        this.clearAuth();
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  // Projects methods
-  getProjects(): ProjectsConfig | undefined {
-    return this.config.get("projects");
-  }
-
-  setProjects(projects: ProjectsConfig): void {
-    this.config.set("projects", projects);
-  }
-
-  getDefaultProject(): string | undefined {
-    const projects = this.getProjects();
-    return projects?.default;
-  }
-
-  setDefaultProject(projectId: string): void {
-    const projects = this.getProjects() || { list: [] };
-    projects.default = projectId;
-    this.setProjects(projects);
-  }
-
-  addProject(project: { id: string; name: string; apiUrl?: string }): void {
-    const projects = this.getProjects() || { list: [] };
-    const existingIndex = projects.list.findIndex(p => p.id === project.id);
-
-    if (existingIndex >= 0) {
-      projects.list[existingIndex] = project;
-    } else {
-      projects.list.push(project);
-    }
-
-    this.setProjects(projects);
-  }
-
-  getProject(projectId: string): { id: string; name: string; apiUrl?: string } | undefined {
-    const projects = this.getProjects();
-    return projects?.list.find(p => p.id === projectId);
-  }
-
-  // Sync methods
-  getSyncConfig(): SyncConfig | undefined {
-    return this.config.get("sync");
-  }
-
-  setSyncConfig(sync: SyncConfig): void {
-    this.config.set("sync", sync);
-  }
-
-  // Utility methods
-  getConfigPath(): string {
-    return this.config.path;
-  }
-
-  clear(): void {
-    this.config.clear();
-  }
-}
-
-// Export singleton instance
-export const configManager = new ConfigManager(); 

package/src/index.ts

@@ -1,49 +0,0 @@
-#!/usr/bin/env node
-
-import { Command } from 'commander';
-import chalk from 'chalk';
-import fs from 'fs';
-
-// Import commands
-import { loginCommand } from './commands/auth/login';
-import { logoutCommand } from './commands/auth/logout';
-import { authStatusCommand } from './commands/auth/status';
-import { syncCommand } from './commands/sync';
-import { projectsListCommand } from './commands/projects/list';
-import { projectsSetDefaultCommand } from './commands/projects/set-default';
-import { projectsCurrentCommand } from './commands/projects/current';
-import { configCommand } from './commands/config/index';
-
-const program = new Command();
-const packageJson = JSON.parse(fs.readFileSync('./package.json', 'utf8'));
-const version = packageJson.version;
-
-// Set up the CLI
-program
-  .name('buildx')
-  .description('BuildX CLI - API authentication and schema synchronization tool')
-  .version(version, '-v, --version');
-
-// Add commands
-program.addCommand(loginCommand);
-program.addCommand(logoutCommand);
-program.addCommand(authStatusCommand);
-program.addCommand(syncCommand);
-program.addCommand(projectsListCommand);
-program.addCommand(projectsSetDefaultCommand);
-program.addCommand(projectsCurrentCommand);
-program.addCommand(configCommand);
-
-// Global error handler
-program.exitOverride();
-
-try {
-  program.parse();
-} catch (err) {
-  if (err instanceof Error) {
-    console.error(chalk.red('Error:'), err.message);
-  } else {
-    console.error(chalk.red('An unexpected error occurred'));
-  }
-  process.exit(1);
-} 

package/src/services/api.ts

@@ -1,132 +0,0 @@
-import axios, { AxiosInstance, AxiosRequestConfig, InternalAxiosRequestConfig } from "axios";
-import { configManager } from "../config/index";
-import { ApiResponse, LoginCredentials, LoginResponse } from "../types/index";
-
-export class ApiService {
-  private client: AxiosInstance;
-
-  constructor() {
-    this.client = axios.create({
-      timeout: 30000,
-      headers: {
-        "Content-Type": "application/json",
-        "User-Agent": "buildx-cli/1.0.0"
-      }
-    });
-
-    // Add request interceptor to include auth token and API key
-    this.client.interceptors.request.use((config: InternalAxiosRequestConfig) => {
-      // Ensure client is initialized with current config before each request
-      this.initializeClient();
-
-      // Add API key from configuration
-      const apiConfig = configManager.getApiConfig();
-      if (apiConfig?.apiKey) {
-        config.headers["X-API-Key"] = apiConfig.apiKey;
-      }
-
-      // Add auth token
-      const auth = configManager.getAuth();
-      if (auth?.token) {
-        config.headers.Authorization = `Bearer ${auth.token}`;
-      }
-      return config;
-    });
-
-    // Add response interceptor for error handling
-    this.client.interceptors.response.use(
-      (response) => response,
-      (error: any) => {
-        if (error.response?.status === 401) {
-          configManager.clearAuth();
-          throw new Error("Authentication failed. Please login again.");
-        }
-        throw error;
-      }
-    );
-  }
-
-  private initializeClient(): void {
-    const apiConfig = configManager.getApiConfig();
-    if (apiConfig?.endpoint) {
-      this.client.defaults.baseURL = apiConfig.endpoint;
-      console.log(`Debug: Setting base URL to ${apiConfig.endpoint}`);
-    } else {
-      throw new Error("API endpoint not configured. Please run 'buildx config setup' first.");
-    }
-  }
-
-  private async request<T>(config: AxiosRequestConfig): Promise<ApiResponse<T>> {
-    // Always set baseURL from config before making the request
-    const apiConfig = configManager.getApiConfig();
-    if (!apiConfig?.endpoint) {
-      throw new Error("API endpoint not configured. Please run 'buildx config setup' first.");
-    }
-    config.baseURL = apiConfig.endpoint;
-    try {
-      const response = await this.client.request(config);
-      return {
-        data: response.data,
-        status: response.status,
-        message: response.statusText
-      };
-    } catch (error: any) {
-      if (error.response) {
-        throw new Error(`API Error: ${error.response.status} - ${error.response.data?.message || error.response.statusText}`);
-      } else if (error.request) {
-        throw new Error("Network error: Unable to connect to the API");
-      } else {
-        throw new Error(`Request error: ${error.message}`);
-      }
-    }
-  }
-
-  async login(credentials: LoginCredentials): Promise<LoginResponse> {
-    const response = await this.request<LoginResponse>({
-      method: "POST",
-      url: "/auth/login",
-      data: credentials
-    });
-    return response.data;
-  }
-
-  async getProjects(): Promise<{ id: string; name: string; apiUrl?: string }[]> {
-    const response = await this.request<{ projects: { id: string; name: string; apiUrl?: string }[] }>({
-      method: "GET",
-      url: "/projects"
-    });
-    return response.data.projects;
-  }
-
-  async getSchema(projectId: string): Promise<string> {
-    const response = await this.request<string>({
-      method: "GET",
-      url: `/project/${projectId}/collections/schema`
-    });
-
-    return response.data;
-  }
-
-  async getMe(): Promise<{ username: string;[key: string]: any }> {
-    const response = await this.request<{ username: string;[key: string]: any }>({
-      method: "GET",
-      url: "/auth/me"
-    });
-    return response.data;
-  }
-
-  setBaseUrl(baseUrl: string): void {
-    this.client.defaults.baseURL = baseUrl;
-  }
-
-  getBaseUrl(): string {
-    return this.client.defaults.baseURL || '';
-  }
-
-  isConfigured(): boolean {
-    return configManager.isApiConfigured();
-  }
-}
-
-// Export singleton instance
-export const apiService = new ApiService(); 

package/src/services/schema-generator.ts

@@ -1,132 +0,0 @@
-import fs from "fs-extra";
-import path from "path";
-import { SchemaResponse, SchemaCollection, SchemaField } from "../types/index";
-
-export class SchemaGenerator {
-	private generateFieldType(field: SchemaField): string {
-		const baseType = this.mapFieldTypeToTypeScript(field.type);
-		return field.required ? baseType : `${baseType} | null`;
-	}
-
-	private mapFieldTypeToTypeScript(apiType: string): string {
-		const typeMap: Record<string, string> = {
-			"string": "string",
-			"text": "string",
-			"number": "number",
-			"integer": "number",
-			"float": "number",
-			"boolean": "boolean",
-			"date": "string",
-			"datetime": "string",
-			"timestamp": "string",
-			"json": "Record<string, any>",
-			"array": "any[]",
-			"object": "Record<string, any>",
-			"email": "string",
-			"url": "string",
-			"uuid": "string",
-			"id": "string"
-		};
-
-		return typeMap[apiType.toLowerCase()] || "any";
-	}
-
-	private generateCollectionInterface(collection: SchemaCollection): string {
-		const interfaceName = this.toPascalCase(collection.name);
-		const fields = collection.fields.map(field => {
-			const fieldType = this.generateFieldType(field);
-			const optional = field.required ? "" : "?";
-			const comment = field.description ? `\n  /** ${field.description} */` : "";
-			return `${comment}\n  ${field.name}${optional}: ${fieldType};`;
-		}).join("\n");
-
-		const description = collection.description ? `\n/** ${collection.description} */` : "";
-
-		return `${description}
-export interface ${interfaceName} {
-${fields}
-}`;
-	}
-
-	private toPascalCase(str: string): string {
-		return str
-			.split(/[-_\s]+/)
-			.map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-			.join("");
-	}
-
-	private generateIndexExports(collections: SchemaCollection[]): string {
-		const exports = collections.map(collection => {
-			const interfaceName = this.toPascalCase(collection.name);
-			return `export type { ${interfaceName} } from './${collection.name}';`;
-		}).join("\n");
-
-		return exports;
-	}
-
-	private generateCollectionFile(collection: SchemaCollection): string {
-		const interfaceContent = this.generateCollectionInterface(collection);
-		return `// Generated by BuildX CLI
-// Collection: ${collection.name}
-// Generated at: ${new Date().toISOString()}
-
-${interfaceContent}
-`;
-	}
-
-	async generateTypes(schema: SchemaResponse, outputPath: string): Promise<void> {
-		const outputDir = path.dirname(outputPath);
-		const baseName = path.basename(outputPath, path.extname(outputPath));
-		const outputDirPath = path.join(outputDir, baseName);
-
-		// Ensure output directory exists
-		await fs.ensureDir(outputDirPath);
-
-		// Generate individual collection files
-		for (const collection of schema.collections) {
-			const collectionFileName = `${collection.name}.ts`;
-			const collectionFilePath = path.join(outputDirPath, collectionFileName);
-			const collectionContent = this.generateCollectionFile(collection);
-      
-			await fs.writeFile(collectionFilePath, collectionContent, "utf8");
-		}
-
-		// Generate index file
-		const indexContent = `// Generated by BuildX CLI
-// Schema version: ${schema.version}
-// Generated at: ${schema.generatedAt}
-
-${this.generateIndexExports(schema.collections)}
-
-// Re-export all types for convenience
-export * from './${schema.collections[0]?.name || "index"}';
-`;
-
-		const indexFilePath = path.join(outputDirPath, "index.ts");
-		await fs.writeFile(indexFilePath, indexContent, "utf8");
-
-		// Generate main types file
-		const mainContent = `// Generated by BuildX CLI
-// Schema version: ${schema.version}
-// Generated at: ${schema.generatedAt}
-
-${schema.collections.map(collection => this.generateCollectionInterface(collection)).join("\n\n")}
-
-// Export all collection types
-${schema.collections.map(collection => {
-		const interfaceName = this.toPascalCase(collection.name);
-		return `export type { ${interfaceName} };`;
-	}).join("\n")}
-`;
-
-		await fs.writeFile(outputPath, mainContent, "utf8");
-	}
-
-	async generateTypesToFile(schema: SchemaResponse, outputPath: string): Promise<string> {
-		await this.generateTypes(schema, outputPath);
-		return outputPath;
-	}
-}
-
-// Export singleton instance
-export const schemaGenerator = new SchemaGenerator(); 

package/src/types/index.ts

@@ -1,91 +0,0 @@
-export interface AuthConfig {
-  token: string;
-  expiresAt?: string;
-  username?: string;
-}
-
-export interface LoginCredentials {
-  username: string;
-  password: string;
-}
-
-export interface LoginResponse {
-  token: string;
-  expiresAt?: string;
-  user?: {
-    id: string;
-    username: string;
-    email?: string;
-  };
-}
-
-export interface ApiConfig {
-  endpoint: string;
-  apiKey: string;
-}
-
-export interface Project {
-  id: string;
-  name: string;
-  apiUrl?: string;
-}
-
-export interface ProjectsConfig {
-  default?: string;
-  list: Project[];
-}
-
-export interface SyncConfig {
-  outputPath: string;
-}
-
-export interface GlobalConfig {
-  api?: ApiConfig;
-  auth?: AuthConfig;
-  projects?: ProjectsConfig;
-  sync?: SyncConfig;
-}
-
-export interface ApiResponse<T = any> {
-  data: T;
-  status: number;
-  message?: string;
-}
-
-export interface SchemaField {
-  name: string;
-  type: string;
-  required?: boolean;
-  description?: string;
-  defaultValue?: any;
-}
-
-export interface SchemaCollection {
-  name: string;
-  fields: SchemaField[];
-  description?: string;
-}
-
-export interface SchemaResponse {
-  collections: SchemaCollection[];
-  version: string;
-  generatedAt: string;
-}
-
-export interface LoginOptions {
-  token?: string;
-  username?: string;
-  password?: string;
-  interactive?: boolean;
-}
-
-export interface SyncOptions {
-  projectId: string;
-  output?: string;
-  apiUrl?: string;
-  force?: boolean;
-}
-
-export interface ProjectOptions {
-  projectId: string;
-} 

package/src/utils/logger.ts

@@ -1,29 +0,0 @@
-import chalk from "chalk";
-
-export class Logger {
-	static info(message: string): void {
-		console.log(chalk.blue("ℹ"), message);
-	}
-
-	static success(message: string): void {
-		console.log(chalk.green("✓"), message);
-	}
-
-	static warning(message: string): void {
-		console.log(chalk.yellow("⚠"), message);
-	}
-
-	static error(message: string): void {
-		console.error(chalk.red("✗"), message);
-	}
-
-	static debug(message: string): void {
-		if (process.env.DEBUG) {
-			console.log(chalk.gray("🐛"), message);
-		}
-	}
-
-	static log(message: string): void {
-		console.log(message);
-	}
-} 

package/tsconfig.json

@@ -1,29 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext",
-    "lib": ["ES2020"],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "resolveJsonModule": true,
-    "moduleResolution": "node",
-    "allowSyntheticDefaultImports": true,
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true
-  },
-  "include": [
-    "src/**/*"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist",
-    "**/*.test.ts"
-  ]
-}