buildx-cli 1.0.8 → 1.0.10

package/src/services/schema-types-convert.ts

@@ -0,0 +1,361 @@
+import { matchByFilters } from "../utils/sync";
+
+type BxFieldAnnotations = {
+	title?: string;
+	description?: string;
+	required?: boolean;
+	ref?: string;
+	choices?: Array<{ value: string; label: string }>;
+};
+
+export function splitTopLevelMembers(objectBody: string): string[] {
+	const members: string[] = [];
+	let current = "";
+	let braceDepth = 0;
+	let bracketDepth = 0;
+	let parenDepth = 0;
+	let angleDepth = 0;
+
+	for (let i = 0; i < objectBody.length; i++) {
+		const ch = objectBody[i];
+		if (ch === "{") braceDepth++;
+		if (ch === "}") braceDepth = Math.max(0, braceDepth - 1);
+		if (ch === "[") bracketDepth++;
+		if (ch === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+		if (ch === "(") parenDepth++;
+		if (ch === ")") parenDepth = Math.max(0, parenDepth - 1);
+		if (ch === "<") angleDepth++;
+		if (ch === ">") angleDepth = Math.max(0, angleDepth - 1);
+
+		if (ch === ";" && braceDepth === 0 && bracketDepth === 0 && parenDepth === 0 && angleDepth === 0) {
+			if (current.trim()) members.push(current.trim());
+			current = "";
+			continue;
+		}
+		current += ch;
+	}
+
+	if (current.trim()) {
+		members.push(current.trim());
+	}
+	return members;
+}
+
+export function parseCollectionIdEnum(source: string): Map<string, string> {
+	const map = new Map<string, string>();
+	const enumMatch = source.match(/export\s+enum\s+BxCollectionId\s*{([\s\S]*?)}/m);
+	if (!enumMatch) return map;
+
+	const body = enumMatch[1];
+	const entryRegex = /([A-Za-z0-9_]+)\s*=\s*"([^"]+)"/g;
+	let m: RegExpExecArray | null;
+	while ((m = entryRegex.exec(body)) !== null) {
+		map.set(m[1], m[2]);
+	}
+	return map;
+}
+
+export function parseExportedObjectTypes(source: string): Array<{ typeName: string; body: string }> {
+	const results: Array<{ typeName: string; body: string }> = [];
+	const regex = /export\s+type\s+([A-Za-z0-9_]+)\s*=\s*{/g;
+	let match: RegExpExecArray | null;
+	while ((match = regex.exec(source)) !== null) {
+		const typeName = match[1];
+		if (typeName.startsWith("Bx")) continue;
+
+		const braceStart = source.indexOf("{", match.index);
+		if (braceStart < 0) continue;
+
+		let depth = 0;
+		let end = -1;
+		for (let i = braceStart; i < source.length; i++) {
+			const ch = source[i];
+			if (ch === "{") depth++;
+			if (ch === "}") {
+				depth--;
+				if (depth === 0) {
+					end = i;
+					break;
+				}
+			}
+		}
+		if (end < 0) continue;
+
+		results.push({
+			typeName,
+			body: source.slice(braceStart + 1, end)
+		});
+		regex.lastIndex = end;
+	}
+	return results;
+}
+
+export function resolveCollectionId(typeName: string, enumMap: Map<string, string>): string {
+	const mapped = enumMap.get(typeName);
+	if (mapped) return mapped;
+	return typeName
+		.replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+		.replace(/-/g, "_")
+		.toLowerCase();
+}
+
+export function mapScalarTypeToFieldType(typeText: string): string {
+	const normalized = typeText.trim().replace(/^\((.*)\)$/, "$1");
+	if (["string", "BxText", "BxEmail", "BxUrl", "BxObjectId", "BxAuth", "BxPhoneNumber", "BxSequence"].includes(normalized)) return "Text";
+	if (["BxLongText", "BxRichText"].includes(normalized)) return "LongText";
+	if (["number", "BxNumber", "BxInteger"].includes(normalized)) return "Number";
+	if (["boolean", "BxBoolean"].includes(normalized)) return "Toggle";
+	if (["BxCheckbox"].includes(normalized)) return "Checkbox";
+	if (["Date", "BxDate"].includes(normalized)) return "Date";
+	if (["BxDateTime"].includes(normalized)) return "DateTime";
+	if (["BxChoices"].includes(normalized)) return "Choices";
+	if (["BxMultipleChoices"].includes(normalized)) return "MultipleChoices";
+	if (["BxUser"].includes(normalized)) return "User";
+	if (["BxUsers"].includes(normalized)) return "Users";
+	if (["BxFiles"].includes(normalized)) return "Files";
+	if (["BxImages"].includes(normalized)) return "Images";
+	if (["BxObject"].includes(normalized)) return "Object";
+	if (["BxList"].includes(normalized)) return "List";
+	if (["BxContent"].includes(normalized)) return "Content";
+	return "Text";
+}
+
+export function convertTypeFieldToSchemaField(typeText: string, optional: boolean): any {
+	const required = !optional;
+	const requiredPart = required ? { required: true } : {};
+	const raw = typeText.trim();
+	const compact = raw.replace(/\s+/g, "");
+	const unionParts = raw.split("|").map((part) => part.trim()).filter(Boolean);
+	const nonNullable = unionParts.filter((part) => part !== "null" && part !== "undefined");
+	const primary = nonNullable[0] || raw;
+
+	const singleRefMatch = compact.match(/^(?:Partial<([A-Za-z0-9_]+)>\|BxDataObject|BxDataObject\|Partial<([A-Za-z0-9_]+)>)$/);
+	const singleRef = singleRefMatch?.[1] || singleRefMatch?.[2];
+	if (singleRef) {
+		return {
+			type: "DataObject",
+			...requiredPart,
+			propertiesScheme: { ref: singleRef }
+		};
+	}
+	const manyRefMatch = compact.match(/^(?:Partial<([A-Za-z0-9_]+)>\[\]\|BxDataObject\[\]|BxDataObject\[\]\|Partial<([A-Za-z0-9_]+)>\[\])$/);
+	const manyRef = manyRefMatch?.[1] || manyRefMatch?.[2];
+	if (manyRef) {
+		return {
+			type: "DataObjects",
+			...requiredPart,
+			propertiesScheme: { ref: manyRef }
+		};
+	}
+
+	if (primary.endsWith("[]")) {
+		const inner = primary.slice(0, -2).trim().replace(/^\((.*)\)$/, "$1");
+		return {
+			type: "List",
+			...requiredPart,
+			propertiesScheme: {
+				children: [{ name: "item", type: mapScalarTypeToFieldType(inner) }]
+			}
+		};
+	}
+
+	if (primary.startsWith("{") && primary.endsWith("}")) {
+		return {
+			type: "Object",
+			...requiredPart,
+			propertiesScheme: { children: [] }
+		};
+	}
+
+	return {
+		type: mapScalarTypeToFieldType(primary),
+		...requiredPart
+	};
+}
+
+function parseBxFieldAnnotations(memberText: string): BxFieldAnnotations {
+	const annotations: BxFieldAnnotations = {};
+	const blocks = memberText.match(/\/\*\*[\s\S]*?\*\//g) || [];
+	for (const block of blocks) {
+		const content = block
+			.replace(/^\/\*\*?/, "")
+			.replace(/\*\/$/, "")
+			.split("\n")
+			.map((line) => line.replace(/^\s*\*\s?/, ""))
+			.join("\n");
+		const tagRegex = /@bx\.([a-z_]+)\s*([\s\S]*?)(?=@bx\.|$)/gi;
+		let match: RegExpExecArray | null;
+		while ((match = tagRegex.exec(content)) !== null) {
+			const [, keyRaw, valueRaw] = match;
+			const key = keyRaw.toLowerCase();
+			const value = valueRaw.trim();
+			if (key === "title" && value) annotations.title = value;
+			if (key === "description" && value) annotations.description = value;
+			if (key === "ref" && value) annotations.ref = value;
+			if (key === "required") {
+				if (!value) {
+					annotations.required = true;
+				} else {
+					annotations.required = !["false", "0", "no"].includes(value.toLowerCase());
+				}
+			}
+			if (key === "choices" && value) {
+				annotations.choices = value
+					.split("|")
+					.map((part) => part.trim())
+					.filter(Boolean)
+					.map((part) => {
+						const separator = part.indexOf(":");
+						if (separator < 0) {
+							return { value: part, label: part };
+						}
+						const choiceValue = part.slice(0, separator).trim();
+						const choiceLabel = part.slice(separator + 1).trim();
+						return {
+							value: choiceValue,
+							label: choiceLabel
+						};
+					});
+			}
+		}
+	}
+	return annotations;
+}
+
+function stripCommentsForFieldParse(memberText: string): string {
+	return memberText
+		.replace(/\/\*[\s\S]*?\*\//g, " ")
+		.replace(/\/\/.*$/gm, " ")
+		.trim();
+}
+
+function applyFieldAnnotations(fieldSchema: any, annotations: BxFieldAnnotations, warnings: string[], fieldPath: string): any {
+	const next = { ...fieldSchema };
+	if (annotations.title) next.title = annotations.title;
+	if (annotations.description) next.description = annotations.description;
+	if (annotations.required !== undefined) {
+		if (annotations.required) {
+			next.required = true;
+		} else {
+			delete next.required;
+		}
+	}
+	if (annotations.ref) {
+		next.propertiesScheme = {
+			...(next.propertiesScheme || {}),
+			ref: annotations.ref
+		};
+	}
+	if (annotations.choices) {
+		if (next.type === "Choices" || next.type === "MultipleChoices") {
+			next.propertiesScheme = {
+				...(next.propertiesScheme || {}),
+				choices: annotations.choices
+			};
+		} else {
+			warnings.push(`Field "${fieldPath}" has @bx.choices but inferred type is "${next.type}"`);
+		}
+	}
+	return next;
+}
+
+export function buildCollectionsFromTypes(typeContent: string, filters: string[]): { collections: any[]; warnings: string[] } {
+	const enumMap = parseCollectionIdEnum(typeContent);
+	const typeBlocks = parseExportedObjectTypes(typeContent);
+	const warnings: string[] = [];
+	const collections: any[] = [];
+
+	for (const block of typeBlocks) {
+		const collectionId = resolveCollectionId(block.typeName, enumMap);
+		if (!matchByFilters(collectionId, filters)) continue;
+
+		const members = splitTopLevelMembers(block.body);
+		const formSchema: Record<string, any> = {};
+		for (const member of members) {
+			const annotations = parseBxFieldAnnotations(member);
+			const trimmed = stripCommentsForFieldParse(member);
+			if (!trimmed || trimmed.startsWith("//")) continue;
+			const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)\??\s*:\s*([\s\S]+)$/);
+			if (!match) continue;
+			const [, fieldName, typeTextRaw] = match;
+			const optional = /\?\s*:/.test(trimmed);
+			if (["_id", "__bxstate"].includes(fieldName)) continue;
+
+			const fieldSchema = convertTypeFieldToSchemaField(typeTextRaw.trim(), optional);
+			if (fieldSchema.type === "Text" && !/^(string|BxText|BxEmail|BxUrl|BxObjectId|BxAuth|BxUser|BxPhoneNumber|BxSequence)\b/.test(typeTextRaw.trim())) {
+				warnings.push(`Field "${collectionId}.${fieldName}" used fallback Text for type "${typeTextRaw.trim()}"`);
+			}
+			if (fieldSchema.propertiesScheme?.ref && enumMap.has(fieldSchema.propertiesScheme.ref)) {
+				fieldSchema.propertiesScheme.ref = enumMap.get(fieldSchema.propertiesScheme.ref);
+			}
+			const annotatedField = applyFieldAnnotations(fieldSchema, annotations, warnings, `${collectionId}.${fieldName}`);
+			if (annotatedField.propertiesScheme?.ref && enumMap.has(annotatedField.propertiesScheme.ref)) {
+				annotatedField.propertiesScheme.ref = enumMap.get(annotatedField.propertiesScheme.ref);
+			}
+			formSchema[fieldName] = annotatedField;
+		}
+
+		collections.push({
+			collection_id: collectionId,
+			form_schema: formSchema
+		});
+	}
+	return { collections, warnings };
+}
+
+export function mergeSchemaField(baseField: any, inferredField: any): any {
+	if (!baseField) return inferredField;
+	if (!inferredField) return baseField;
+
+	const merged: any = {
+		...baseField,
+		...inferredField
+	};
+
+	const fieldType = String(inferredField.type || merged.type || "");
+	const baseProperties = baseField.propertiesScheme || {};
+	const inferredProperties = inferredField.propertiesScheme || {};
+
+	if (fieldType === "DataObject" || fieldType === "DataObjects") {
+		merged.propertiesScheme = {
+			...(baseProperties.ref ? { ref: baseProperties.ref } : {}),
+			...(baseProperties.local_key ? { local_key: baseProperties.local_key } : {}),
+			...(baseProperties.foreign_key ? { foreign_key: baseProperties.foreign_key } : {}),
+			...(baseProperties.schema ? { schema: baseProperties.schema } : {}),
+			...(inferredProperties.ref ? { ref: inferredProperties.ref } : {}),
+			...(inferredProperties.local_key ? { local_key: inferredProperties.local_key } : {}),
+			...(inferredProperties.foreign_key ? { foreign_key: inferredProperties.foreign_key } : {}),
+			...(inferredProperties.schema ? { schema: inferredProperties.schema } : {})
+		};
+	} else if (baseField.propertiesScheme || inferredField.propertiesScheme) {
+		merged.propertiesScheme = {
+			...baseProperties,
+			...inferredProperties
+		};
+	}
+	return merged;
+}
+
+export function mergeCollectionWithBase(baseCollection: any, inferredCollection: any): any {
+	const baseSchema = baseCollection?.form_schema && typeof baseCollection.form_schema === "object"
+		? baseCollection.form_schema
+		: {};
+	const inferredSchema = inferredCollection?.form_schema && typeof inferredCollection.form_schema === "object"
+		? inferredCollection.form_schema
+		: {};
+
+	const mergedSchema: Record<string, any> = {};
+	const keys = new Set<string>([
+		...Object.keys(baseSchema),
+		...Object.keys(inferredSchema)
+	]);
+	for (const key of keys) {
+		mergedSchema[key] = mergeSchemaField(baseSchema[key], inferredSchema[key]);
+	}
+
+	return {
+		...inferredCollection,
+		...baseCollection,
+		form_schema: mergedSchema
+	};
+}

package/src/types/index.ts

@@ -0,0 +1,91 @@
+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 {
+  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/env.ts

@@ -0,0 +1,117 @@
+import fs from "fs";
+import path from "path";
+
+export interface EnvConfig {
+	BUILDX_API_ENDPOINT?: string;
+	BUILDX_API_KEY?: string;
+	BUILDX_PROJECT_ID?: string;
+	_sources?: {
+		endpointKey?: string;
+		apiKeyKey?: string;
+		projectIdKey?: string;
+	};
+}
+
+export function loadEnvConfig(): EnvConfig {
+	const envConfig: EnvConfig = {};
+	const fileEnv: Record<string, string> = {};
+
+	const endpointCandidates = [
+		"BUILDX_API_ENDPOINT",
+		"NEXT_PUBLIC_BUILDX_API_ENDPOINT",
+		"NEXT_PUBLIC_API_ENDPOINT"
+	];
+	const apiKeyCandidates = [
+		"BUILDX_API_KEY",
+		"NEXT_PUBLIC_BUILDX_API_KEY",
+		"NEXT_PUBLIC_API_KEY"
+	];
+	const projectIdCandidates = [
+		"BUILDX_PROJECT_ID",
+		"NEXT_PUBLIC_BUILDX_PROJECT_ID"
+	];
+
+	// Try to load .env file
+	const envPath = path.resolve(process.cwd(), ".env");
+	if (fs.existsSync(envPath)) {
+		try {
+			const envContent = fs.readFileSync(envPath, "utf8");
+			const envLines = envContent.split("\n");
+
+			for (const line of envLines) {
+				const trimmedLine = line.trim();
+				if (trimmedLine && !trimmedLine.startsWith("#")) {
+					const [key, ...valueParts] = trimmedLine.split("=");
+					if (key && valueParts.length > 0) {
+						const value = valueParts.join("=").replace(/^["']|["']$/g, ""); // Remove quotes
+						if (
+							endpointCandidates.includes(key) ||
+							apiKeyCandidates.includes(key) ||
+							projectIdCandidates.includes(key)
+						) {
+							fileEnv[key] = value;
+						}
+					}
+				}
+			}
+		} catch (error) {
+			console.warn("Warning: Could not read .env file:", error);
+		}
+	}
+
+	const envSources = {
+		...fileEnv,
+		...Object.fromEntries(
+			Object.entries(process.env)
+				.filter(([key, value]) => {
+					if (!value) return false;
+					return (
+						endpointCandidates.includes(key) ||
+						apiKeyCandidates.includes(key) ||
+						projectIdCandidates.includes(key)
+					);
+				})
+				.map(([key, value]) => [key, String(value)])
+		)
+	};
+
+	for (const key of endpointCandidates) {
+		if (envSources[key]) {
+			envConfig.BUILDX_API_ENDPOINT = envSources[key];
+			envConfig._sources = {
+				...(envConfig._sources || {}),
+				endpointKey: key
+			};
+			break;
+		}
+	}
+
+	for (const key of apiKeyCandidates) {
+		if (envSources[key]) {
+			envConfig.BUILDX_API_KEY = envSources[key];
+			envConfig._sources = {
+				...(envConfig._sources || {}),
+				apiKeyKey: key
+			};
+			break;
+		}
+	}
+
+	for (const key of projectIdCandidates) {
+		if (envSources[key]) {
+			envConfig.BUILDX_PROJECT_ID = envSources[key];
+			envConfig._sources = {
+				...(envConfig._sources || {}),
+				projectIdKey: key
+			};
+			break;
+		}
+	}
+
+	return envConfig;
+}
+
+export function hasEnvConfig(): boolean {
+	const envConfig = loadEnvConfig();
+	return !!(envConfig.BUILDX_API_ENDPOINT && envConfig.BUILDX_API_KEY);
+} 

package/src/utils/logger.ts

@@ -0,0 +1,29 @@
+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/src/utils/sync.ts

@@ -0,0 +1,70 @@
+import crypto from "crypto";
+import path from "path";
+import fs from "fs-extra";
+
+export function sha256(content: string): string {
+	return crypto.createHash("sha256").update(content).digest("hex");
+}
+
+function deepSort(value: any): any {
+	if (Array.isArray(value)) {
+		return value.map(deepSort);
+	}
+	if (value && typeof value === "object") {
+		const sorted: Record<string, any> = {};
+		for (const key of Object.keys(value).sort()) {
+			sorted[key] = deepSort(value[key]);
+		}
+		return sorted;
+	}
+	return value;
+}
+
+export function stableStringify(value: any): string {
+	return JSON.stringify(deepSort(value));
+}
+
+export function objectChecksum(value: any): string {
+	return sha256(stableStringify(value));
+}
+
+export function toAbsolutePath(filePath: string): string {
+	if (path.isAbsolute(filePath)) {
+		return filePath;
+	}
+	return path.resolve(process.cwd(), filePath);
+}
+
+export async function readJsonIfExists<T = any>(filePath: string): Promise<T | null> {
+	if (!(await fs.pathExists(filePath))) {
+		return null;
+	}
+	return fs.readJson(filePath) as Promise<T>;
+}
+
+export function sanitizeFileName(name: string): string {
+	return name.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+
+export function parseFilters(filterInput?: string[] | string): string[] {
+	if (!filterInput) return [];
+	const items = Array.isArray(filterInput) ? filterInput : [filterInput];
+	return items
+		.flatMap((item) => String(item).split(","))
+		.map((item) => item.trim())
+		.filter(Boolean);
+}
+
+function wildcardToRegExp(pattern: string): RegExp {
+	const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+	const regexText = `^${escaped.replace(/\*/g, ".*")}$`;
+	return new RegExp(regexText, "i");
+}
+
+export function matchByFilters(value: string, filters: string[]): boolean {
+	if (!filters.length) return true;
+	return filters.some((filter) => {
+		const regExp = wildcardToRegExp(filter);
+		return regExp.test(value);
+	});
+}

package/test.env

@@ -0,0 +1,2 @@
+BUILDX_API_ENDPOINT=https://test-api.example.com
+BUILDX_API_KEY=test-api-key-123 

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "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"
+  ]
+}