buildx-cli 1.0.10 → 1.0.11

package/src/config/index.ts

@@ -1,169 +0,0 @@
-import Conf from "conf";
-import { GlobalConfig, AuthConfig, ProjectsConfig, SyncConfig, ApiConfig } from "../types/index";
-import { loadEnvConfig } from "../utils/env";
-
-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: "./buildx/generated/types.ts"
-				}
-			}
-		});
-	}
-
-	// API configuration methods
-	getApiConfig(): ApiConfig | undefined {
-		const storedConfig = this.config.get("api");
-		if (storedConfig?.endpoint && storedConfig?.apiKey) {
-			return storedConfig;
-		}
-
-		// Fallback to environment variables
-		const envConfig = loadEnvConfig();
-		if (envConfig.BUILDX_API_ENDPOINT && envConfig.BUILDX_API_KEY) {
-			return {
-				endpoint: envConfig.BUILDX_API_ENDPOINT,
-				apiKey: envConfig.BUILDX_API_KEY
-			};
-		}
-
-		return undefined;
-	}
-
-	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: { project_id: string; name: string; apiUrl?: string }): void {
-		const projects = this.getProjects() || { list: [] };
-		const existingIndex = projects.list.findIndex(p => p.project_id === project.project_id);
-
-		if (existingIndex >= 0) {
-			projects.list[existingIndex] = project;
-		} else {
-			projects.list.push(project);
-		}
-
-		this.setProjects(projects);
-	}
-
-	getProject(projectId: string): { project_id: string; name: string; apiUrl?: string } | undefined {
-		const projects = this.getProjects();
-		return projects?.list.find(p => p.project_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,62 +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 { schemaDiffCommand, schemaListCommand, syncCommand, schemaPushCommand, schemaPullCommand, schemaTypesConvertCommand } from './commands/sync';
-import { functionDiffCommand, functionListCommand, functionPushCommand, functionSyncCommand, functionPullCommand } from './commands/functions';
-import { projectsListCommand } from './commands/projects/list';
-import { projectsSetDefaultCommand } from './commands/projects/set-default';
-import { projectsCurrentCommand } from './commands/projects/current';
-import { configSetupCommand, configShowCommand, configClearCommand } from './commands/config';
-
-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, project management, and schema synchronization tool')
-  .version(version, '-v, --version');
-
-// Add commands
-program.addCommand(loginCommand);
-program.addCommand(logoutCommand);
-program.addCommand(authStatusCommand);
-program.addCommand(syncCommand);
-program.addCommand(schemaPullCommand);
-program.addCommand(schemaPushCommand);
-program.addCommand(schemaListCommand);
-program.addCommand(schemaDiffCommand);
-program.addCommand(schemaTypesConvertCommand);
-program.addCommand(functionSyncCommand);
-program.addCommand(functionPullCommand);
-program.addCommand(functionPushCommand);
-program.addCommand(functionListCommand);
-program.addCommand(functionDiffCommand);
-program.addCommand(projectsListCommand);
-program.addCommand(projectsSetDefaultCommand);
-program.addCommand(projectsCurrentCommand);
-program.addCommand(configSetupCommand);
-program.addCommand(configShowCommand);
-program.addCommand(configClearCommand);
-
-// 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,198 +0,0 @@
-import axios from "axios";
-import type { AxiosInstance, AxiosRequestConfig, InternalAxiosRequestConfig } from "axios";
-import { configManager } from "../config/index";
-import { ApiResponse, LoginCredentials, LoginResponse, Project } 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;
-		} 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);
-			if (response.data.error) {
-				// Got error message if exists
-				if (response.data.message) {
-					throw new Error(`${response.data.error} (${response.data.message})`);
-				} else {
-					throw new Error(response.data.error);
-				}
-			}
-			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<Project[]> {
-		const response = await this.request<{ projects: Project[] }>({
-			method: "GET",
-			url: "/projects"
-		});
-		return response.data as unknown as Project[];
-	}
-
-	async getSchema(projectId: string): Promise<string> {
-		const response = await this.request<string>({
-			method: "GET",
-			url: `/project/${projectId}/collections/schema`
-		});
-
-		return response.data;
-	}
-
-	async getCollections(projectId: string): Promise<any[]> {
-		const response = await this.request<any[]>({
-			method: "GET",
-			url: `/project/${projectId}/collections`
-		});
-		return response.data;
-	}
-
-	async upsertCollection(projectId: string, collection: Record<string, any>): Promise<any> {
-		const response = await this.request<any>({
-			method: "POST",
-			url: `/project/${projectId}/collections`,
-			data: collection
-		});
-		return response.data;
-	}
-
-	async getFunctionContextSchema(projectId: string): Promise<string> {
-		const response = await this.request<string>({
-			method: "GET",
-			url: `/project/${projectId}/functions/context/schema`
-		});
-		return response.data;
-	}
-
-	async getFunctionContextSchemaInfo(projectId: string): Promise<{ schema: string; checksum: string; version: number }> {
-		const response = await this.request<{ schema: string; checksum: string; version: number }>({
-			method: "GET",
-			url: `/project/${projectId}/functions/context/schema/info`
-		});
-		return response.data;
-	}
-
-	async listFunctions(projectId: string): Promise<any[]> {
-		const response = await this.request<any[]>({
-			method: "GET",
-			url: `/project/${projectId}/functions`
-		});
-		return response.data;
-	}
-
-	async getFunction(projectId: string, functionName: string): Promise<any> {
-		const response = await this.request<any>({
-			method: "GET",
-			url: `/project/${projectId}/functions/${encodeURIComponent(functionName)}`
-		});
-		return response.data;
-	}
-
-	async upsertFunction(projectId: string, functionName: string, payload: Record<string, any>): Promise<any> {
-		const response = await this.request<any>({
-			method: "POST",
-			url: `/project/${projectId}/functions/${encodeURIComponent(functionName)}`,
-			data: payload
-		});
-		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();