bundo-appgen 0.0.1-beta.7

package/src/_bin/_global-vars/index.mts

@@ -0,0 +1,30 @@
+import type {
+	Config,
+} from "../../index.mts"
+
+import {
+	globalVars,
+} from "./_global-vars.mts"
+
+export namespace GlobalVars {
+
+	/**
+	 * This is evaluated bundo.config.ts from user app.
+	 */
+	export const appConfig = globalVars<Config.Data>("app_config", {})
+
+	export const argv = globalVars("argv", {
+		clean: false,
+		forceCrossPlatform: false,
+		path: "",
+		xcodegenPath: "",
+	})
+
+	/**
+	 * `bundo-appgen` directory
+	 */
+	export const appgenRoot = globalVars("appgen_root", "")
+
+	export const configFilePath = globalVars("config_file_path", "")
+
+}

package/src/_bin/_main/_check-config-validity.mts

@@ -0,0 +1,94 @@
+import type {
+	Config,
+} from "../../index.mts"
+
+import {
+	GlobalVars,
+} from "../_global-vars/index.mts"
+
+import {
+	ConfigHelpers,
+} from "./_helpers/index.mts"
+
+export function checkConfigValidity(
+	config: Config.Data,
+) {
+
+	if(
+		!config.macos /* && !config.windows */
+	) {
+		throw new Error("No platforms configuration.")
+	}
+
+	const isCrossPlatform = GlobalVars.argv.get().forceCrossPlatform
+
+	if(isCrossPlatform) {
+		checkMacosConfig(config)
+		// TODO windows
+	} else if(process.platform == "darwin") {
+		checkMacosConfig(config)
+	} else if(process.platform == "win32") {
+		// TODO windows
+	}
+
+	// check plugin
+	if(config.plugins) {
+		if(Array.isArray(config.plugins)) {
+			config.plugins.forEach(plugin => {
+				let isValid = true
+
+				if(Array.isArray(plugin) && plugin.length) {
+					isValid = typeof plugin[0] === "string"
+
+					if(plugin.length > 2) {
+						isValid = false
+					} else if(plugin[1]) {
+						isValid = typeof plugin[1] === "object" && plugin[1].constructor === Object
+					}
+				} else if(typeof plugin === "string" && !plugin.length) {
+					isValid = false
+				}
+
+				if(!isValid) {
+					throw new Error("Plugin item needs to be an string of the plugin name, or an array of the plugin name and its parameter.")
+				}
+			})
+		} else {
+			throw new Error("Expected an Array in the plugin registry.")
+		}
+	}
+
+}
+
+class OSFieldError extends Error {
+
+	constructor(
+		prop: string,
+		os: "macos" | "windows",
+	) {
+		super(`\`${prop}\` is required for ${os} app.`)
+	}
+
+}
+
+function checkMacosConfig(config: Config.Data) {
+	if(!ConfigHelpers.getName(config, "macos")) {
+		throw new Error("`name` or `macos.name` is required in the config.")
+	}
+
+	if(!config.macos) {
+		throw new Error(`Missing macos property in the config.`)
+	}
+
+	if(!config.macos.buildVersion) {
+		throw new OSFieldError("buildVersion", "macos")
+	}
+
+	if(!config.macos.bundleIdentifier) {
+		throw new OSFieldError("bundleIdentifier", "macos")
+	}
+
+	if(!config.macos.version) {
+		throw new OSFieldError("version", "macos")
+	}
+}

package/src/_bin/_main/_evaluate-plugin-registry.mts

@@ -0,0 +1,181 @@
+import * as node_fs from "node:fs"
+import * as node_module from "node:module"
+import * as node_path from "node:path"
+
+import type {
+	Config,
+	Plugin,
+} from "../../index.mts"
+
+import {
+	GlobalVars,
+} from "../_global-vars/index.mts"
+
+import type {
+	EvaluatedPluginRegistry,
+} from "../plugin-sandbox-runner/index.ts"
+
+/**
+ * Evaluate the plugin registry to get their main function path file and its parameter
+ * that will be invoked later through our plugin runner.
+ */
+export function evaluatePluginRegistry(
+	plugins: Config.PluginRegistry | undefined,
+): EvaluatedPluginRegistry | undefined {
+
+	if(!plugins?.length) {
+		return undefined
+	}
+
+	const registry: NonNullable<ReturnType<typeof evaluatePluginRegistry>> = []
+
+	for(const plugin of plugins) {
+		let
+			nameOrPath: string,
+
+			parameter: Plugin.Context["parameter"] =
+				undefined
+
+		if(typeof plugin === "string" && plugin) {
+			nameOrPath = plugin
+		} else if(Array.isArray(plugin) && plugin.length && typeof plugin[0] === "string" && plugin[0]) {
+			nameOrPath = plugin[0]
+
+			if(plugin[1]) {
+				if(
+					typeof plugin[1] === "object" &&
+					plugin[1].constructor === Object
+				) {
+					parameter = plugin[1]
+				} else {
+					throw new Error(`The plugin parameter is only supported in plain object. Caused by "${nameOrPath}".`)
+				}
+			}
+		} else {
+			throw new Error("The plugin registry is not a valid schema in the config.")
+		}
+
+		// test if the plugin is in the node_modules
+		const mainPathFromNodeModule = getPluginMainPathFromNodeModules(nameOrPath)
+		if(mainPathFromNodeModule) {
+			registry.push({
+				name: nameOrPath,
+				mainPath: mainPathFromNodeModule,
+				parameter,
+			})
+			continue
+		}
+
+		// test if the plugin is a local file
+		const filePath = node_path.join(
+			node_path.dirname(GlobalVars.configFilePath.get()),
+			nameOrPath,
+		)
+		if(node_fs.existsSync(filePath)) {
+			const lstat = node_fs.lstatSync(filePath)
+
+			if(lstat.isFile()) {
+				registry.push({
+					name: nameOrPath,
+					mainPath: filePath,
+					parameter,
+				})
+				continue
+			} else {
+				throw new Error(`${filePath} is not a file.`)
+			}
+		}
+
+		throw new Error(`"${nameOrPath}" plugin cannot be found.`)
+	}
+
+	return registry
+
+}
+
+/**
+ * We try to find `bundo.plugin.mjs`, or `bundo.plugin.js`, or their custom JavaScript file in their module directory.
+ * 
+ * For examples
+ * 
+ * - "@foo-scope/react-native-module-bar"
+ * 	- node_modules/@foo-scope/react-native-module-bar/bundo.plugin.mjs
+ * 	- node_modules/@foo-scope/react-native-module-bar/bundo.plugin.js
+ * 
+ * - "@bar/react-native-module-foo/plugins"
+ * 	- node_modules/@bar/react-native-module-foo/plugins/bundo.plugin.mjs
+ * 	- node_modules/@bar/react-native-module-foo/plugins/bundo.plugin.js
+ * 
+ * - "react-native-abc/foo/bar/xyz.js"
+ * 	- node_modules/react-native-abc/foo/bar/xyz.js 
+ * 
+ * This function also resolve the path to actual file path, not the symbolic link.
+ */
+function getPluginMainPathFromNodeModules(name: string): string | undefined {
+	let modulePath: string | undefined
+	let isDirectory = true
+
+	try {
+		const __require = node_module.createRequire(node_path.join(process.cwd(), "package.json"))
+		const nodeModulePaths = __require.resolve.paths("bundo-appgen")
+
+		if(nodeModulePaths?.length) {
+			for(const nodeModulePath of nodeModulePaths) {
+				const __modulePath = node_path.join(nodeModulePath, name)
+
+				if(node_fs.existsSync(__modulePath)) {
+					const modulePathStat = node_fs.lstatSync(__modulePath)
+
+					if(modulePathStat.isFile()) {
+						isDirectory = false
+					}
+
+					if(modulePathStat.isSymbolicLink()) {
+						modulePath = node_fs.realpathSync(__modulePath)
+					} else {
+						modulePath = __modulePath
+					}
+
+					break
+				}
+			}
+		}
+
+		// nothing to found
+		if(!modulePath) {
+			return undefined
+		}
+	} catch {
+		return undefined
+	}
+
+	if(!isDirectory) {
+		// `modulePath` is actually a JavaScript file
+		// Skip finding the `bundo.plugin.[mjs|js] file`
+		return modulePath
+	}
+
+	let mainPath: string | undefined
+
+	for(const pluginMainFileExt of pluginMainFileExts) {
+		const path = node_path.join(modulePath, `bundo.plugin.${pluginMainFileExt}`)
+
+		if(node_fs.existsSync(path)) {
+			// test again for the desired path is symbolic link or not.
+			const lstat = node_fs.lstatSync(path)
+			if(lstat.isSymbolicLink()) {
+				mainPath = node_fs.realpathSync(path)
+			} else {
+				mainPath = path
+			}
+			break
+		}
+	}
+
+	return mainPath
+}
+
+const pluginMainFileExts = [
+	"mjs",
+	"js",
+]

package/src/_bin/_main/_exec-plugin-runner/_spawn-plugin-sandbox-runner.mts

@@ -0,0 +1,149 @@
+import * as node_childProcess from "node:child_process"
+import * as node_fs from "node:fs"
+import * as node_module from "node:module"
+import * as node_path from "node:path"
+
+import {
+	GlobalVars,
+} from "../../_global-vars/index.mts"
+
+import type {
+	EvaluatedPluginRegistry,
+	PluginRunnerContextResult,
+} from "../../plugin-sandbox-runner/index.ts"
+
+import type * as PluginSandboxRunnerType from "../../plugin-sandbox-runner/index.ts"
+
+/**
+ * We allow some fs read for some directories by default
+ * - node_modules directory lookup
+ * - plugins directory
+ */
+export async function spawnPluginSandboxRunner(
+	registry: EvaluatedPluginRegistry,
+	permissions: {
+		"--allow-fs-read": string[] | null,
+		"--allow-fs-write": string[] | null,
+		"--allow-net": boolean,
+	},
+	metadata: {
+		projectDirectory: string,
+		projectName: string,
+	},
+): Promise<PluginRunnerContextResult> {
+	const
+		requireModule =
+			node_module.createRequire(process.cwd()),
+
+		messageID =
+			Math.random().toString()
+
+	return new Promise(resolve => {
+		const nodeArgs: string[] = [
+			"--permission",
+		]
+
+		permissions["--allow-fs-read"]?.forEach(path => {
+			nodeArgs.push(`--allow-fs-read=${path}`)
+		})
+
+		permissions["--allow-fs-write"]?.forEach(path => {
+			nodeArgs.push(`--allow-fs-write=${path}`)
+		})
+
+		if(permissions["--allow-net"]) {
+			nodeArgs.push("--allow-net")
+		}
+
+		// allow read for node_modules directory
+		// required for plugins to use their external module
+		requireModule.resolve.paths("bundo-appgen")?.forEach(nodeModulePath => {
+			if(nodeModulePath.slice(-("/node".length)) != "/node") {
+				nodeArgs.push(`--allow-fs-read=${nodeModulePath}`)
+			}
+		})
+
+		// allow read for plugins directory
+		// required for plugins to use their own splitted JavaScript files in their own directory
+		registry.forEach(plugin => {
+			const pluginDirectory = node_path.dirname(plugin.mainPath)
+			const lstat = node_fs.lstatSync(pluginDirectory)
+
+			if(lstat.isSymbolicLink()) {
+				nodeArgs.push(`--allow-fs-read=${node_fs.realpathSync(pluginDirectory)}`)
+			}
+			nodeArgs.push(`--allow-fs-read=${pluginDirectory}`)
+		})
+
+		// exec plugin-sandbox-runner.mjs
+		nodeArgs.push(
+			node_path.join(
+				GlobalVars.appgenRoot.get(),
+				"lib", "bin", "plugin-sandbox-runner.mjs",
+			),
+		)
+		// and its arguments
+		nodeArgs.push(
+			`--json=${JSON.stringify({
+				projectDirectory: metadata.projectDirectory,
+				projectName: metadata.projectName,
+				evaluatedPluginRegistry: registry,
+				messageID,
+			} satisfies PluginSandboxRunnerType.ArgvJSON)}`,
+		)
+
+		// -------------------------------
+		// ----- SPAWN A NEW PROCESS -----
+		// -------------------------------
+
+		const pluginRunner = node_childProcess.spawn(
+			"node",
+			nodeArgs,
+			{
+				stdio: [
+					"pipe",
+					"pipe",
+					"inherit",
+					"ipc",
+				],
+			},
+		)
+
+		let message: string
+
+		pluginRunner.on("message", clientMessage => {
+			if(typeof clientMessage === "string") {
+				message = clientMessage
+			}
+		})
+
+		pluginRunner.on("exit", code => {
+			if(code == 0) {
+				if(message) {
+					// Improve me!
+					// Only trust specific JSON message here
+
+					const json = JSON.parse(message) as Record<string, unknown>
+
+					// See /packages/bundo-appgen/plugin-sandbox-runner.mts
+					// Check the contract
+					if(
+						json.messageID === messageID &&
+
+						json.macos &&
+						typeof json.macos === "object"
+					) {
+						delete json.messageID
+						resolve(json as PluginRunnerContextResult)
+					} else {
+						throw new Error("Plugin Sandbox Runner was not sending a valid result.")
+					}
+				} else {
+					throw new Error("Plugin Sandbox Runner was not sending a valid result.")
+				}
+			} else {
+				throw new Error(`Plugin Sandbox Runner exited with ${code} code`)
+			}
+		})
+	})
+}

package/src/_bin/_main/_exec-plugin-runner/exec-plugin-runner.mts

@@ -0,0 +1,92 @@
+import * as node_path from "node:path"
+
+import {
+	GlobalVars,
+} from "../../_global-vars/index.mts"
+
+import type {
+	EvaluatedPluginRegistry,
+	PluginRunnerContextResult,
+} from "../../plugin-sandbox-runner/index.ts"
+
+import {
+	ConfigHelpers,
+} from "../_helpers/index.mts"
+
+import {
+	spawnPluginSandboxRunner,
+} from "./_spawn-plugin-sandbox-runner.mts"
+
+export async function execPluginRunner(
+	registry: EvaluatedPluginRegistry | undefined,
+	options?: {
+		mode:
+			| "restricted"
+			| "lessRestrictive",
+	},
+): Promise<PluginRunnerContextResult | undefined> {
+
+	if(!registry?.length) {
+		return undefined
+	}
+
+	const
+		projectDirectory =
+			node_path.dirname(GlobalVars.configFilePath.get()),
+
+		projectName =
+			ConfigHelpers.getProjectName(GlobalVars.appConfig.get(), "macos")! // already validated
+
+	if(options?.mode === "restricted") {
+		console.log(`Executing ${registry.length} plugin${registry.length == 1 ? "" : "s"}`)
+		return await spawnPluginSandboxRunner(
+			registry,
+			{
+				"--allow-fs-read": [
+					// +++++ allow read for specific template files +++++
+					node_path.join(
+						projectDirectory,
+						"macos", projectName, "AppDelegate.swift",
+					),
+
+					node_path.join(
+						projectDirectory,
+						"macos", "Podfile",
+					),
+					// ----- allow read for specific template files -----
+				],
+				"--allow-fs-write": null,
+				"--allow-net": false,
+			},
+			{
+				projectDirectory,
+				projectName,
+			},
+		)
+	} else {
+		console.log(`Executing ${registry.length} less restrictive plugin${registry.length == 1 ? "" : "s"}`)
+
+		const
+			projectDirectoryMacos =
+				node_path.join(projectDirectory, "macos")
+		// TODO - Windows
+
+		return await spawnPluginSandboxRunner(
+			registry,
+			{
+				"--allow-fs-read": [
+					projectDirectoryMacos,
+				],
+				"--allow-fs-write": [
+					projectDirectoryMacos,
+				],
+				"--allow-net": true,
+			},
+			{
+				projectDirectory,
+				projectName,
+			},
+		)
+	}
+
+}

package/src/_bin/_main/_exec-plugin-runner/index.mts

@@ -0,0 +1 @@
+export * from "./exec-plugin-runner.mts"

package/src/_bin/_main/_get-config.mts

@@ -0,0 +1,64 @@
+import * as node_module from "node:module"
+import * as node_path from "node:path"
+
+import type {
+	Config,
+} from "../../index.mts"
+
+export async function getConfig(
+	configFilePath: string,
+): Promise<Config.Data> {
+	const ext = node_path.extname(configFilePath)
+
+	if(ext == ".ts" || ext == ".mts") {
+		// Bun with the `--bun` flag
+		if(typeof Bun !== "undefined" || process.versions.bun) {
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
+			return import(configFilePath).then(c => c.default)
+		}
+
+		// Transpile and evaluate the TypeScript file
+		// Possibly in Node.js with `tsx`
+
+		// bundo-appgen library is intentionally putting the `tsx` as a optional dependency,
+		// instead of peer or dev dependency
+		// to respect users by warning them to install `tsx` manually
+
+		// To be honest, I don't know much about TypeScript compiler API.
+		// If someone in the future know much about TypeScript compiler API,
+		// we don't need the `tsx` anymore.
+
+		console.log("Resolving your TypeScript file config…")
+
+		try {
+			return import("tsx/cjs/api").then(async tsx => {
+				const result = await tsx.require(configFilePath, __filename) as {
+					default: Config.Data,
+				}
+
+				return result.default
+			})
+		} catch(err) {
+			if(err instanceof Error && "code" in err && err.code === "ERR_MODULE_NOT_FOUND") {
+				// eslint-disable-next-line preserve-caught-error
+				throw new Error(`
+For TypeScript config file, please install \`tsx\` as your dev dependency,
+or you can use Bun, or just use the JavaScript config file.
+`)
+			}
+
+			throw err
+		}
+	}
+
+	// Pure JS
+
+	if(ext == ".mjs") {
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
+		return import(configFilePath).then(c => c.default)
+	}
+
+	const requireModule = node_module.createRequire(configFilePath)
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+	return requireModule(configFilePath)
+}

package/src/_bin/_main/_helpers/config/get-name.mts

@@ -0,0 +1,24 @@
+import type {
+	Config,
+} from "../../../../index.mts"
+
+/**
+ * Get the app name from the config. This function is not guaranteed to return valid string due to missing value in the config object.
+ */
+export function getName(
+	config: Config.Data,
+	platform:
+		| "macos"
+		| "windows"
+		| "ios",
+): string | undefined {
+
+	if(platform == "macos") {
+		return config.macos?.name || config.name
+	}
+
+	// TODO: Windows
+
+	return config.name
+
+}

package/src/_bin/_main/_helpers/config/get-project-name.mts

@@ -0,0 +1,27 @@
+import {
+	getName,
+} from "./get-name.mts"
+
+let cache: string
+
+/**
+ * Get the project name for Xcode or Visual Studio. This function is not guaranteed to return valid string due to missing value in the config object.
+ */
+export function getProjectName(
+	...params: Parameters<typeof getName>
+): string | undefined {
+
+	if(cache) {
+		return cache
+	}
+
+	const name = getName(...params)
+
+	if(!name) {
+		return undefined
+	}
+
+	cache = name.replace(/[^a-zA-Z0-9]/g, "")
+	return cache
+
+}

package/src/_bin/_main/_helpers/config/index.mts

@@ -0,0 +1,2 @@
+export * from "./get-name.mts"
+export * from "./get-project-name.mts"

package/src/_bin/_main/_helpers/index.mts

@@ -0,0 +1,2 @@
+export * as ConfigHelpers from "./config/index.mts"
+export * as PlatformHelpers from "./platform/index.mts"

package/src/_bin/_main/_helpers/platform/compatibility-error.mts

@@ -0,0 +1,7 @@
+export const CompatibilityError = new Error(`
+Cannot run bundo.rn appgen CLI in non compatible platform or JavaScript development runtime.
+
+bundo.rn CLIs are compatible for
+Platforms: macOS, Windows, Linux
+Development Runtime: Bun, Node.js
+	`)

package/src/_bin/_main/_helpers/platform/data.ts

@@ -0,0 +1,9 @@
+export interface Data {
+	developmentRuntime: {
+		type: "bun" | "node",
+		/**
+		 * The semver without the "v" prepended.
+		 */
+		version: string,
+	},
+}