buildx-cli 1.0.8 → 1.0.10

package/src/__tests__/config.test.ts

@@ -0,0 +1,102 @@
+import { ConfigManager } from "../config";
+
+describe("ConfigManager", () => {
+	let configManager: ConfigManager;
+
+	beforeEach(() => {
+		configManager = new ConfigManager();
+		configManager.clear();
+	});
+
+	afterEach(() => {
+		configManager.clear();
+	});
+
+	describe("Authentication", () => {
+		it("should store and retrieve auth token", () => {
+			const auth = {
+				token: "test-token",
+				expiresAt: new Date().toISOString()
+			};
+
+			configManager.setAuth(auth);
+			const retrieved = configManager.getAuth();
+
+			expect(retrieved).toEqual(auth);
+		});
+
+		it("should clear auth token", () => {
+			const auth = {
+				token: "test-token",
+				expiresAt: new Date().toISOString()
+			};
+
+			configManager.setAuth(auth);
+			configManager.clearAuth();
+
+			expect(configManager.getAuth()).toBeUndefined();
+		});
+
+		it("should check if authenticated", () => {
+			expect(configManager.isAuthenticated()).toBe(false);
+
+			const auth = {
+				token: "test-token",
+				expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString() // 1 day from now
+			};
+
+			configManager.setAuth(auth);
+			expect(configManager.isAuthenticated()).toBe(true);
+		});
+
+		it("should handle expired token", () => {
+			const auth = {
+				token: "test-token",
+				expiresAt: new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString() // 1 day ago
+			};
+
+			configManager.setAuth(auth);
+			expect(configManager.isAuthenticated()).toBe(false);
+		});
+	});
+
+	describe("Projects", () => {
+		it("should store and retrieve projects", () => {
+			const projects = {
+				default: "project-1",
+				list: [
+					{ project_id: "project-1", name: "Project 1" },
+					{ project_id: "project-2", name: "Project 2" }
+				]
+			};
+
+			configManager.setProjects(projects);
+			const retrieved = configManager.getProjects();
+
+			expect(retrieved).toEqual(projects);
+		});
+
+		it("should set default project", () => {
+			const projects = {
+				list: [
+					{ project_id: "project-1", name: "Project 1" },
+					{ project_id: "project-2", name: "Project 2" }
+				]
+			};
+
+			configManager.setProjects(projects);
+			configManager.setDefaultProject("project-2");
+
+			const updated = configManager.getProjects();
+			expect(updated?.default).toBe("project-2");
+		});
+
+		it("should add project", () => {
+			const project = { project_id: "project-1", name: "Project 1" };
+			configManager.addProject(project);
+
+			const retrieved = configManager.getProject("project-1");
+			expect(retrieved).toEqual(project);
+		});
+	});
+}); 

package/src/__tests__/schema-types-convert.test.ts

@@ -0,0 +1,147 @@
+import {
+	buildCollectionsFromTypes,
+	convertTypeFieldToSchemaField,
+	mapScalarTypeToFieldType,
+	mergeCollectionWithBase
+} from "../services/schema-types-convert";
+
+describe("schema:types:convert internals", () => {
+	describe("mapScalarTypeToFieldType", () => {
+		it("maps buildx scalar aliases to expected field types", () => {
+			expect(mapScalarTypeToFieldType("BxLongText")).toBe("LongText");
+			expect(mapScalarTypeToFieldType("BxChoices")).toBe("Choices");
+			expect(mapScalarTypeToFieldType("BxUser")).toBe("User");
+			expect(mapScalarTypeToFieldType("BxDate")).toBe("Date");
+		});
+	});
+
+	describe("convertTypeFieldToSchemaField", () => {
+		it("converts single and multiple data object references", () => {
+			expect(convertTypeFieldToSchemaField("Partial<Departments> | BxDataObject", true)).toEqual({
+				type: "DataObject",
+				propertiesScheme: { ref: "Departments" }
+			});
+			expect(convertTypeFieldToSchemaField("Partial<TestRef>[] | BxDataObject[]", true)).toEqual({
+				type: "DataObjects",
+				propertiesScheme: { ref: "TestRef" }
+			});
+		});
+	});
+
+	describe("buildCollectionsFromTypes", () => {
+		it("resolves relation refs using BxCollectionId enum", () => {
+			const typeContent = `
+				export enum BxCollectionId {
+					Departments = "departments",
+					Employees = "employees"
+				}
+				export type Employees = {
+					department?: Partial<Departments> | BxDataObject;
+				};
+				export type Departments = {
+					name?: BxText;
+				};
+			`;
+			const { collections, warnings } = buildCollectionsFromTypes(typeContent, []);
+			const employees = collections.find((c) => c.collection_id === "employees");
+			expect(warnings).toEqual([]);
+			expect(employees).not.toHaveProperty("name");
+			expect(employees?.form_schema?.department).toEqual({
+				type: "DataObject",
+				propertiesScheme: { ref: "departments" }
+			});
+		});
+
+		it("supports @bx annotations in JSDoc comments", () => {
+			const typeContent = `
+				export enum BxCollectionId {
+					Employees = "employees"
+				}
+				export type Employees = {
+					/** @bx.title Employment status @bx.choices active:Active|on_leave:On Leave|terminated: */
+					status?: BxChoices;
+					/** @bx.required */
+					employee_id?: BxText;
+					/** @bx.ref employees @bx.title Manager */
+					manager?: Partial<Employees> | BxDataObject;
+				};
+			`;
+			const { collections, warnings } = buildCollectionsFromTypes(typeContent, []);
+			const employees = collections.find((c) => c.collection_id === "employees");
+			expect(warnings).toEqual([]);
+			expect(employees?.form_schema?.status).toEqual({
+				type: "Choices",
+				title: "Employment status",
+				propertiesScheme: {
+					choices: [
+						{ value: "active", label: "Active" },
+						{ value: "on_leave", label: "On Leave" },
+						{ value: "terminated", label: "" }
+					]
+				}
+			});
+			expect(employees?.form_schema?.employee_id).toEqual({
+				type: "Text",
+				required: true
+			});
+			expect(employees?.form_schema?.manager).toEqual({
+				type: "DataObject",
+				title: "Manager",
+				propertiesScheme: { ref: "employees" }
+			});
+		});
+	});
+
+	describe("mergeCollectionWithBase", () => {
+		it("preserves relation metadata and avoids cross-type propertiesScheme leakage", () => {
+			const baseCollection = {
+				collection_id: "test",
+				name: "Test",
+				form_schema: {
+					reference: {
+						type: "DataObjects",
+						required: false,
+						propertiesScheme: {
+							ref: "test_ref",
+							local_key: "_id",
+							foreign_key: "parent_id",
+							schema: {
+								name: { type: "Text", required: true }
+							}
+						}
+					}
+				},
+				timestamps: true,
+				auditable: false
+			};
+
+			const inferredCollection = {
+				collection_id: "test",
+				name: "Test",
+				form_schema: {
+					reference: {
+						type: "DataObjects",
+						propertiesScheme: {
+							ref: "test_ref",
+							children: [{ name: "item", type: "Text" }]
+						}
+					}
+				}
+			};
+
+			const merged = mergeCollectionWithBase(baseCollection, inferredCollection);
+			expect(merged.form_schema.reference).toEqual({
+				type: "DataObjects",
+				required: false,
+				propertiesScheme: {
+					ref: "test_ref",
+					local_key: "_id",
+					foreign_key: "parent_id",
+					schema: {
+						name: { type: "Text", required: true }
+					}
+				}
+			});
+		});
+	});
+});

package/src/commands/auth/login.ts

@@ -0,0 +1,148 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import { configManager } from '../../config/index';
+import { apiService } from '../../services/api';
+import { LoginOptions } from '../../types/index';
+
+export const loginCommand = new Command('auth:login')
+  .description('Authenticate with BuildX API')
+  .option('-t, --token <token>', 'API token for authentication')
+  .option('-u, --username <username>', 'Username for authentication')
+  .option('-p, --password <password>', 'Password for authentication')
+  .option('-i, --interactive', 'Interactive login mode')
+  .action(async (options: LoginOptions) => {
+    try {
+      // Check if API is configured
+      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);
+      }
+
+      let token = options.token;
+      let username = options.username;
+      let password = options.password;
+
+      // If no credentials provided, prompt for them
+      if (!token && !username && !password) {
+        const answers = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'authMethod',
+            message: 'Choose authentication method:',
+            choices: [
+              { name: 'Username & Password', value: 'credentials' },
+              { name: 'API Token', value: 'token' }
+            ]
+          }
+        ]);
+
+        if (answers.authMethod === 'credentials') {
+          const credentialAnswers = await inquirer.prompt([
+            {
+              type: 'input',
+              name: 'username',
+              message: 'Enter your username:',
+              validate: (input: string) => {
+                if (!input || input.trim().length === 0) {
+                  return 'Username is required';
+                }
+                return true;
+              }
+            },
+            {
+              type: 'password',
+              name: 'password',
+              message: 'Enter your password:',
+              validate: (input: string) => {
+                if (!input || input.trim().length === 0) {
+                  return 'Password is required';
+                }
+                return true;
+              }
+            }
+          ]);
+          username = credentialAnswers.username;
+          password = credentialAnswers.password;
+        } else {
+          const tokenAnswer = await inquirer.prompt([
+            {
+              type: 'password',
+              name: 'token',
+              message: 'Enter your API token:',
+              validate: (input: string) => {
+                if (!input || input.trim().length === 0) {
+                  return 'Token is required';
+                }
+                return true;
+              }
+            }
+          ]);
+          token = tokenAnswer.token;
+        }
+      }
+
+      const spinner = ora('Authenticating...').start();
+
+      try {
+        // Only support username/password authentication
+        if (!username || !password) {
+          const credentialAnswers = await inquirer.prompt([
+            {
+              type: 'input',
+              name: 'username',
+              message: 'Enter your username:',
+              validate: (input: string) => {
+                if (!input || input.trim().length === 0) {
+                  return 'Username is required';
+                }
+                return true;
+              }
+            },
+            {
+              type: 'password',
+              name: 'password',
+              message: 'Enter your password:',
+              validate: (input: string) => {
+                if (!input || input.trim().length === 0) {
+                  return 'Password is required';
+                }
+                return true;
+              }
+            }
+          ]);
+          username = credentialAnswers.username;
+          password = credentialAnswers.password;
+        }
+
+        // Username/password authentication only
+        const loginResponse = await apiService.login({ username, password });
+        let authToken = loginResponse.token;
+        let expiresAt = loginResponse.expiresAt;
+        username = username ?? '';
+        authToken = authToken ?? '';
+        expiresAt = expiresAt ?? new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString();
+        configManager.setAuth({
+          token: authToken,
+          expiresAt: expiresAt,
+          username: username
+        });
+
+        spinner.succeed('Successfully authenticated!');
+        console.log(chalk.green('✓ Authentication stored securely'));
+        console.log(chalk.blue('You can now use other BuildX CLI commands'));
+
+      } catch (error) {
+        spinner.fail('Authentication failed');
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+      }
+
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      process.exit(1);
+    }
+  }); 

package/src/commands/auth/logout.ts

@@ -0,0 +1,16 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../../config/index';
+
+export const logoutCommand = new Command('auth:logout')
+  .description('Logout and clear stored authentication')
+  .action(() => {
+    try {
+      configManager.clearAuth();
+      console.log(chalk.green('✓ Successfully logged out'));
+      console.log(chalk.blue('Authentication token has been cleared'));
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      process.exit(1);
+    }
+  }); 

package/src/commands/auth/status.ts

@@ -0,0 +1,52 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../../config/index';
+import { apiService } from '../../services/api';
+import ora from 'ora';
+
+export const authStatusCommand = new Command('auth:status')
+  .description('Check authentication status')
+  .action(async () => {
+    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);
+      }
+      const isAuthenticated = configManager.isAuthenticated();
+      const auth = configManager.getAuth();
+
+      if (isAuthenticated && auth) {
+        const spinner = ora('Validating session...').start();
+        try {
+          // Call /auth/me endpoint
+          const me = await apiService.getMe();
+          spinner.succeed('Authenticated');
+          console.log(chalk.green('✓ Authenticated'));
+          console.log(chalk.blue('Username:'), me.username);
+          if (auth.token) {
+            console.log(chalk.blue('Token:'), auth.token.substring(0, 8) + '...');
+          }
+          if (auth.expiresAt) {
+            console.log(chalk.blue('Expires:'), new Date(auth.expiresAt).toLocaleString());
+          }
+          // console.log(chalk.gray('Raw response:'), JSON.stringify(me, null, 2));
+          if (me.username) {
+            console.log(chalk.blue(`You are authenticated as ${me.source}:${me.username}`));
+          }
+        } catch (error) {
+          spinner.fail('Session invalid');
+          console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+          process.exit(1);
+        }
+      } else {
+        console.log(chalk.red('✗ Not authenticated'));
+        console.log(chalk.yellow('Run "buildx login" to authenticate'));
+      }
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      process.exit(1);
+    }
+  }); 

package/src/commands/config/clear.ts

@@ -0,0 +1,16 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../../config/index';
+
+export const configClearCommand = new Command('config:clear')
+	.description('Clear all CLI configuration (API, auth, projects, sync)')
+	.action(() => {
+		try {
+			configManager.clear();
+			console.log(chalk.green('✅ All configuration cleared.'));
+			console.log(chalk.yellow('You must run "buildx config setup" before using the CLI again.'));
+		} catch (error) {
+			console.error(chalk.red('❌ Failed to clear configuration:'), error instanceof Error ? error.message : 'Unknown error');
+			process.exit(1);
+		}
+	}); 

package/src/commands/config/index.ts

@@ -0,0 +1,14 @@
+import { Command } from 'commander';
+import { setupCommand } from './setup';
+import { configShowCommand } from './show';
+import { configClearCommand } from './clear';
+
+export const configCommand = new Command('config')
+	.description('Manage CLI configuration')
+	.addCommand(setupCommand)
+	.addCommand(configShowCommand)
+	.addCommand(configClearCommand);
+
+export { setupCommand as configSetupCommand } from './setup';
+export { configShowCommand } from './show';
+export { configClearCommand } from './clear'; 

package/src/commands/config/setup.ts

@@ -0,0 +1,108 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { configManager } from '../../config/index';
+import { loadEnvConfig } from '../../utils/env';
+
+export const setupCommand = new Command('config:setup')
+	.description('Configure API endpoint and API key')
+	.option('-e, --endpoint <endpoint>', 'API endpoint URL')
+	.option('-k, --api-key <apiKey>', 'API key')
+	.action(async (options) => {
+		try {
+			let endpoint = options.endpoint;
+			let apiKey = options.apiKey;
+
+			// If not provided via options, prompt interactively
+			if (!endpoint || !apiKey) {
+				console.log(chalk.blue('🔧 BuildX CLI Setup'));
+				console.log(chalk.gray('Configure your API endpoint and API key to get started.'));
+				console.log(chalk.gray('Supports .env / env aliases: NEXT_PUBLIC_API_ENDPOINT, NEXT_PUBLIC_API_KEY, NEXT_PUBLIC_BUILDX_API_ENDPOINT, NEXT_PUBLIC_BUILDX_API_KEY, BUILDX_API_ENDPOINT, BUILDX_API_KEY.\n'));
+
+				const currentConfig = configManager.getApiConfig();
+				const envConfig = loadEnvConfig();
+
+				if (!endpoint && !apiKey && envConfig.BUILDX_API_ENDPOINT && envConfig.BUILDX_API_KEY) {
+					const envApiKey = envConfig.BUILDX_API_KEY;
+					const slicedApiKey = envApiKey.substring(0, 2);
+					const endpointSource = envConfig._sources?.endpointKey || "unknown";
+					const apiKeySource = envConfig._sources?.apiKeyKey || "unknown";
+
+					console.log(chalk.yellow('Detected API config from environment/.env'));
+					console.log(chalk.gray(`  Endpoint: ${envConfig.BUILDX_API_ENDPOINT} (${endpointSource})`));
+					console.log(chalk.gray(`  API Key: ${slicedApiKey}${'*'.repeat(Math.min(envApiKey.length - slicedApiKey.length, 8))}... (${apiKeySource})`));
+
+					const { useEnvConfig } = await inquirer.prompt([
+						{
+							type: 'confirm',
+							name: 'useEnvConfig',
+							message: 'Use detected environment values?',
+							default: true
+						}
+					]);
+
+					if (useEnvConfig) {
+						endpoint = envConfig.BUILDX_API_ENDPOINT;
+						apiKey = envConfig.BUILDX_API_KEY;
+					}
+				}
+
+				if (!endpoint || !apiKey) {
+					const answers = await inquirer.prompt([
+						{
+							type: 'input',
+							name: 'endpoint',
+							message: 'Enter your API endpoint URL:',
+							default: endpoint || currentConfig?.endpoint || envConfig.BUILDX_API_ENDPOINT || 'https://api.buildx.com',
+							validate: (input: string) => {
+								if (!input.trim()) {
+									return 'Endpoint URL is required';
+								}
+								try {
+									new URL(input);
+									return true;
+								} catch {
+									return 'Please enter a valid URL';
+								}
+							}
+						},
+						{
+							type: 'password',
+							name: 'apiKey',
+							message: 'Enter your API key:',
+							default: apiKey || currentConfig?.apiKey || envConfig.BUILDX_API_KEY || '',
+							validate: (input: string) => {
+								if (!input.trim()) {
+									return 'API key is required';
+								}
+								return true;
+							}
+						}
+					]);
+
+					endpoint = answers.endpoint;
+					apiKey = answers.apiKey;
+				}
+			}
+
+			// Save the configuration
+			configManager.setApiConfig({
+				endpoint: endpoint.trim(),
+				apiKey: apiKey.trim()
+			});
+
+			// Show only 2 first characters of the api key
+			const slicedApiKey = apiKey.substring(0, 2);
+
+			console.log(chalk.green('✅ Configuration saved successfully!'));
+			console.log(chalk.gray(`Endpoint: ${endpoint}`));
+			console.log(chalk.gray(`API Key: ${slicedApiKey}${'*'.repeat(Math.min(apiKey.length - slicedApiKey.length, 8))}...`));
+			console.log(chalk.blue('\nYou can now use the CLI commands. Start with:'));
+			console.log(chalk.cyan('  buildx auth:login'));
+			console.log(chalk.cyan('  buildx projects:list'));
+
+		} catch (error) {
+			console.error(chalk.red('❌ Setup failed:'), error instanceof Error ? error.message : 'Unknown error');
+			process.exit(1);
+		}
+	});