@protobase/cli 0.0.0-stage → 0.1.1

package/dist/scaffold/existing-config.js

@@ -0,0 +1,95 @@
+import { defaultColumn } from "../infer/default-column.js";
+import { camelCase } from "../infer/names.js";
+import { parseSource } from "./project.js";
+import path from "node:path";
+import { readFile, readdir } from "node:fs/promises";
+import { Node, SyntaxKind } from "ts-morph";
+//#region src/scaffold/existing-config.ts
+const unquote = (text) => text.replace(/^['"`]|['"`]$/g, "");
+const stringArg = (call, index = 0) => {
+	const arg = call.getArguments()[index];
+	return arg && Node.isStringLiteral(arg) ? arg.getLiteralValue() : void 0;
+};
+const methodCalls = (root, method) => [root, ...root.getDescendantsOfKind(SyntaxKind.CallExpression)].filter((c) => {
+	const expression = c.getExpression();
+	return Node.isPropertyAccessExpression(expression) && expression.getName() === method;
+});
+const describeField = (name, initializer) => {
+	if (!initializer || Node.isNullLiteral(initializer)) return {
+		name,
+		column: defaultColumn(name),
+		ignored: true
+	};
+	let column;
+	let type;
+	let enumValues;
+	let node = initializer;
+	while (Node.isCallExpression(node)) {
+		const expression = node.getExpression();
+		if (!Node.isPropertyAccessExpression(expression)) break;
+		if (expression.getName() === "column") column ??= stringArg(node);
+		if (expression.getExpression().getText() === "f") {
+			type = expression.getName();
+			const arg = node.getArguments()[0];
+			if (type === "enum" && arg && Node.isArrayLiteralExpression(arg)) enumValues = arg.getElements().flatMap((el) => Node.isStringLiteral(el) ? [el.getLiteralValue()] : []);
+			break;
+		}
+		node = expression.getExpression();
+	}
+	return {
+		name,
+		column: column ?? defaultColumn(name),
+		ignored: false,
+		...type && { type },
+		...enumValues && { enumValues }
+	};
+};
+const fieldsObject = (root) => {
+	const arg = methodCalls(root, "fields")[0]?.getArguments()[0];
+	return arg && Node.isObjectLiteralExpression(arg) ? arg : void 0;
+};
+const resourceChain = (source) => {
+	const root = source.getDescendantsOfKind(SyntaxKind.CallExpression).find((call) => call.getExpression().getText() === "resource");
+	const chainTop = root?.getFirstAncestor((a) => Node.isVariableDeclaration(a))?.getInitializer();
+	if (!root || !chainTop || !Node.isCallExpression(chainTop)) return void 0;
+	return {
+		root,
+		chainTop
+	};
+};
+const parseResource = (text, dir) => {
+	const chain = resourceChain(parseSource(text));
+	if (!chain) return void 0;
+	const { root, chainTop } = chain;
+	const name = stringArg(root);
+	const tableCall = methodCalls(chainTop, "table")[0];
+	const table = tableCall && stringArg(tableCall);
+	const fields = fieldsObject(chainTop);
+	if (!name || !table || !fields) return void 0;
+	return {
+		name,
+		table,
+		dir,
+		text,
+		fields: fields.getProperties().flatMap((property) => {
+			if (!Node.isPropertyAssignment(property)) return [];
+			return [describeField(unquote(property.getName()), property.getInitializer())];
+		})
+	};
+};
+const findField = (resource, column) => resource.fields.find((field) => field.ignored ? field.column.toLowerCase() === column.toLowerCase() || field.name === camelCase(column) : field.column === column);
+const readExistingResources = async (configDir) => {
+	const entries = await readdir(configDir, { withFileTypes: true }).catch((error) => {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	});
+	return (await Promise.all(entries.filter((entry) => entry.isDirectory()).map(async (entry) => {
+		const text = await readFile(path.join(configDir, entry.name, "data.ts"), "utf8").catch((error) => {
+			if (error.code === "ENOENT") return void 0;
+			throw error;
+		});
+		return text === void 0 ? void 0 : parseResource(text, entry.name);
+	}))).filter((resource) => resource !== void 0);
+};
+//#endregion
+export { fieldsObject, findField, methodCalls, parseResource, readExistingResources, resourceChain };

package/dist/scaffold/index-file.js

@@ -0,0 +1,18 @@
+import { parseSource } from "./project.js";
+//#region src/scaffold/index-file.ts
+const ensureExports = (text, wanted) => {
+	const source = parseSource(text);
+	for (const { from, names } of wanted) {
+		const declaration = source.getExportDeclarations().find((d) => d.getModuleSpecifierValue() === from);
+		if (!declaration) {
+			source.addStatements(`export { ${names.join(", ")} } from '${from}'`);
+			continue;
+		}
+		const present = declaration.getNamedExports().map((e) => e.getName());
+		declaration.addNamedExports(names.filter((name) => !present.includes(name)));
+	}
+	const result = source.getFullText();
+	return result.endsWith("\n") ? result : `${result}\n`;
+};
+//#endregion
+export { ensureExports };

package/dist/scaffold/plan.js

@@ -0,0 +1,128 @@
+import { tableKey } from "../db/model.js";
+import { keyColumns } from "../db/keys.js";
+import { findField } from "./existing-config.js";
+import { proposeField } from "../infer/proposal.js";
+import { addFieldsToDataFile, renderDataFile } from "./data-file.js";
+import { detectDrift } from "./drift.js";
+import { ensureExports } from "./index-file.js";
+import { assignNames } from "./resource-names.js";
+import { planResource } from "./resource-plan.js";
+import { isExcluded, matchesTarget } from "./targets.js";
+import { uiFields } from "./ui-fields.js";
+import { addUiSections, renderUiFile, viewName } from "./ui-file.js";
+import path from "node:path";
+//#region src/scaffold/plan.ts
+const decideAll = async (table, columns, context, input) => {
+	const key = keyColumns(table) ?? [];
+	const decisions = [];
+	for (const column of columns) {
+		const proposal = proposeField(table, column, context);
+		const decided = await input.decide(proposal, {
+			table: tableKey(table),
+			required: key.includes(column.name)
+		});
+		decisions.push(decided ? {
+			proposal: decided,
+			ignored: false
+		} : {
+			proposal,
+			ignored: true
+		});
+	}
+	return decisions;
+};
+const change = (file, before, after) => before === after ? [] : [{
+	path: file,
+	...before !== void 0 && { before },
+	after
+}];
+const planScaffold = async (input) => {
+	const { configDir, existing, ui } = input;
+	const names = assignNames(input.tables, existing);
+	const byTable = new Map(existing.map((resource) => [resource.table, resource]));
+	const context = (table) => ({
+		table,
+		resourceNameOf: (schema, name) => names.get(`${schema}.${name}`) ?? name
+	});
+	const targets = input.tables.filter((table) => matchesTarget(input.target, table) && !isExcluded(input.excludes, table)).sort((a, b) => tableKey(a).localeCompare(tableKey(b)));
+	const changes = [];
+	const drift = [];
+	const warnings = [];
+	const registrations = [];
+	const writeUi = async (dir, resource, table, current, decisions) => {
+		if (ui.length === 0) return;
+		const file = path.join(configDir, dir, "ui.ts");
+		const before = await input.readText(file);
+		const target = {
+			resource,
+			tableName: table.name,
+			fields: uiFields(table, current, decisions)
+		};
+		changes.push(...change(file, before, before === void 0 ? renderUiFile(target, ui) : addUiSections(before, target, ui)));
+		if (before === void 0) registrations.push({
+			from: `./${dir}/ui`,
+			names: [viewName(resource)]
+		});
+	};
+	for (const table of targets) {
+		const key = tableKey(table);
+		const current = byTable.get(key);
+		if (current) {
+			const pending = table.columns.filter((c) => !input.target.column || c.name === input.target.column).filter((column) => !findField(current, column.name));
+			const decisions = await decideAll(table, pending, context(table), input);
+			const clash = decisions.find((d) => current.fields.some((f) => f.name === d.proposal.name));
+			if (clash) throw new Error(`${key}: field "${clash.proposal.name}" already exists, edit the name`);
+			const file = path.join(configDir, current.dir, "data.ts");
+			changes.push(...change(file, current.text, addFieldsToDataFile(current.text, decisions)));
+			drift.push(...detectDrift(current, table, context(table)));
+			await writeUi(current.dir, current.name, table, current, decisions);
+			continue;
+		}
+		const name = names.get(key);
+		if (!keyColumns(table)) {
+			warnings.push(`${key}: no primary key or unique NOT NULL index, skipped`);
+			continue;
+		}
+		const file = path.join(configDir, name, "data.ts");
+		if (await input.readText(file) !== void 0) throw new Error(`${file} exists but does not declare a resource for ${key}`);
+		const decisions = await decideAll(table, table.columns, context(table), input);
+		const plan = planResource(name, table, decisions);
+		changes.push({
+			path: file,
+			after: renderDataFile(plan)
+		});
+		registrations.push({
+			from: `./${name}/data`,
+			names: [name]
+		});
+		await writeUi(name, name, table, void 0, decisions);
+	}
+	const indexFile = path.join(configDir, "index.ts");
+	const indexBefore = await input.readText(indexFile);
+	const wanted = [...indexBefore === void 0 ? await registerExisting(input, registrations) : [], ...registrations];
+	if (wanted.length > 0 || indexBefore === void 0) changes.push(...change(indexFile, indexBefore, ensureExports(indexBefore ?? "", wanted)));
+	return {
+		changes,
+		drift,
+		warnings
+	};
+};
+const registerExisting = async (input, planned) => {
+	const known = new Set(planned.map((r) => r.from));
+	const registrations = [];
+	for (const resource of input.existing) {
+		const data = `./${resource.dir}/data`;
+		if (!known.has(data)) registrations.push({
+			from: data,
+			names: [resource.name]
+		});
+		const ui = `./${resource.dir}/ui`;
+		if (await input.readText(path.join(input.configDir, resource.dir, "ui.ts")) !== void 0 && !known.has(ui)) registrations.push({
+			from: ui,
+			names: [viewName(resource.name)]
+		});
+	}
+	return registrations;
+};
+//#endregion
+export { planScaffold };

package/dist/scaffold/project.js

@@ -0,0 +1,13 @@
+import { IndentationText, Project, QuoteKind } from "ts-morph";
+//#region src/scaffold/project.ts
+const project = new Project({
+	useInMemoryFileSystem: true,
+	skipAddingFilesFromTsConfig: true,
+	manipulationSettings: {
+		indentationText: IndentationText.TwoSpaces,
+		quoteKind: QuoteKind.Single
+	}
+});
+const parseSource = (text, name = "source.ts") => project.createSourceFile(name, text, { overwrite: true });
+//#endregion
+export { parseSource };

package/dist/scaffold/prompt.js

@@ -0,0 +1,70 @@
+import { renderField } from "../infer/render-field.js";
+import { createInterface } from "node:readline/promises";
+//#region src/scaffold/prompt.ts
+const acceptAll = async (proposal) => proposal;
+const types = [
+	"text",
+	"integer",
+	"bigint",
+	"decimal",
+	"boolean",
+	"date",
+	"timestamp",
+	"uuid",
+	"json",
+	"enum",
+	"relation",
+	"currency",
+	"country"
+];
+const retype = async (proposal, ask) => {
+	const answer = (await ask(`  type (${types.join(", ")}) [${proposal.type}]: `)).trim();
+	if (!answer || answer === proposal.type) return proposal;
+	const type = types.find((t) => t === answer);
+	if (!type) {
+		process.stdout.write(`  unknown type "${answer}", keeping ${proposal.type}\n`);
+		return proposal;
+	}
+	const { enumValues, relation, precision, scale, defaultValue, ...rest } = proposal;
+	const next = {
+		...rest,
+		type
+	};
+	if (type === "enum") next.enumValues = (await ask("  enum values, comma separated: ")).split(",").map((v) => v.trim()).filter(Boolean);
+	if (type === "relation") next.relation = { resource: (await ask("  related resource: ")).trim() };
+	if (type === "decimal") {
+		next.precision = Number(await ask("  precision [38]: ") || 38);
+		next.scale = Number(await ask("  scale [9]: ") || 9);
+	}
+	return next;
+};
+const edit = async (proposal, ask) => {
+	const name = (await ask(`  field name [${proposal.name}]: `)).trim() || proposal.name;
+	return retype({
+		...proposal,
+		name
+	}, ask);
+};
+const interactive = () => {
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	const decide = async (initial, { table, required }) => {
+		let proposal = initial;
+		for (;;) {
+			process.stdout.write(`\n${table}.${proposal.column}\n  ${proposal.name}: ${renderField(proposal)}\n`);
+			const options = required ? "[a]ccept, [e]dit" : "[a]ccept, [e]dit, [i]gnore";
+			const answer = (await rl.question(`  ${options} (a): `)).trim().toLowerCase() || "a";
+			if (answer === "a") return proposal;
+			if (answer === "e") proposal = await edit(proposal, (q) => rl.question(q));
+			if (answer === "i" && !required) return null;
+		}
+	};
+	return {
+		decide,
+		close: () => rl.close()
+	};
+};
+//#endregion
+export { acceptAll, interactive };

package/dist/scaffold/resource-names.js

@@ -0,0 +1,19 @@
+import { tableKey } from "../db/model.js";
+import { camelCase } from "../infer/names.js";
+//#region src/scaffold/resource-names.ts
+const assignNames = (tables, existing) => {
+	const names = new Map(existing.map((resource) => [resource.table, resource.name]));
+	const taken = new Set(names.values());
+	const fresh = tables.filter((table) => !names.has(tableKey(table)));
+	const counts = /* @__PURE__ */ new Map();
+	for (const table of tables) counts.set(camelCase(table.name), (counts.get(camelCase(table.name)) ?? 0) + 1);
+	for (const table of fresh) {
+		const plain = camelCase(table.name);
+		const name = counts.get(plain) === 1 && !taken.has(plain) ? plain : camelCase(`${table.schema}_${table.name}`);
+		names.set(tableKey(table), name);
+		taken.add(name);
+	}
+	return names;
+};
+//#endregion
+export { assignNames };

package/dist/scaffold/resource-plan.js

@@ -0,0 +1,33 @@
+import { tableKey } from "../db/model.js";
+import { keyColumns } from "../db/keys.js";
+import { isTenantColumn } from "../infer/tenant.js";
+//#region src/scaffold/resource-plan.ts
+const softDeleteColumn = /^(deleted|removed|archived)_(at|on)$/;
+const isSoftDeleteColumn = (table, column) => softDeleteColumn.test(column) && table.columns.some((c) => c.name === column && !c.notNull && [
+	"timestamp",
+	"timestamptz",
+	"date"
+].includes(c.typeName));
+const planResource = (name, table, decisions) => {
+	const key = keyColumns(table);
+	if (!key) return void 0;
+	const kept = decisions.filter((d) => !d.ignored).map((d) => d.proposal);
+	const nameOf = (column) => kept.find((p) => p.column === column)?.name;
+	const find = (test) => {
+		return kept.find((p) => test(p.column))?.name;
+	};
+	const primaryKey = key.map(nameOf);
+	if (primaryKey.some((n) => n === void 0)) throw new Error(`${tableKey(table)}: key columns cannot be ignored`);
+	const primary = table.indexes.find((index) => index.primary);
+	return {
+		name,
+		table,
+		decisions,
+		primaryKey,
+		softDelete: find((c) => isSoftDeleteColumn(table, c)),
+		tenant: find(isTenantColumn),
+		unique: table.indexes.filter((index) => index.unique && !index.partial && index !== primary).flatMap((index) => index.columns.every((c) => c !== null) ? [index.columns] : [])
+	};
+};
+//#endregion
+export { isSoftDeleteColumn, planResource };

package/dist/scaffold/run.js

@@ -0,0 +1,53 @@
+import { connect } from "../db/connect.js";
+import { introspect } from "../db/introspect.js";
+import { readExistingResources } from "./existing-config.js";
+import { parseTarget } from "./targets.js";
+import { planScaffold } from "./plan.js";
+import { acceptAll, interactive } from "./prompt.js";
+import path from "node:path";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { createTwoFilesPatch } from "diff";
+//#region src/scaffold/run.ts
+const readText = (file) => readFile(file, "utf8").catch((error) => {
+	if (error.code === "ENOENT") return void 0;
+	throw error;
+});
+const write = async ({ path: file, after }) => {
+	await mkdir(path.dirname(file), { recursive: true });
+	await writeFile(file, after);
+};
+const runScaffold = async (options, out) => {
+	if (!options.yes && !process.stdin.isTTY) throw new Error("Interactive scaffolding needs a terminal; pass --yes to accept all proposals");
+	const sql = connect(options.url);
+	const prompter = options.yes ? void 0 : interactive();
+	const plan = await (async () => {
+		try {
+			return await planScaffold({
+				tables: await introspect(sql),
+				existing: await readExistingResources(options.configDir),
+				configDir: options.configDir,
+				target: parseTarget(options.target),
+				excludes: options.excludes,
+				decide: prompter?.decide ?? acceptAll,
+				ui: options.ui,
+				readText
+			});
+		} finally {
+			prompter?.close();
+			await sql.end();
+		}
+	})();
+	for (const change of plan.changes) if (options.dryRun) out(createTwoFilesPatch(change.path, change.path, change.before ?? "", change.after));
+	else await write(change);
+	for (const change of plan.changes) if (!options.dryRun) out(`${change.before === void 0 ? "created" : "updated"} ${change.path}\n`);
+	if (plan.changes.length === 0) out("Nothing to do, config is up to date.\n");
+	else if (options.dryRun) out(`${plan.changes.length} file(s) would change; nothing was written (--dry-run).\n`);
+	for (const warning of plan.warnings) out(`warning: ${warning}\n`);
+	if (plan.drift.length > 0) {
+		out("\nDrift:\n");
+		for (const d of plan.drift) out(`  ${d.resource}.${d.field}: ${d.problem}\n    suggested: ${d.suggestion}\n`);
+	}
+	return plan;
+};
+//#endregion
+export { runScaffold };

package/dist/scaffold/targets.js

@@ -0,0 +1,15 @@
+//#region src/scaffold/targets.ts
+const parseTarget = (text) => {
+	if (!text || text === "all") return {};
+	const [schema, table, column, ...extra] = text.split(".");
+	if (extra.length > 0) throw new Error(`Invalid target "${text}", expected all, schema, schema.table or schema.table.column`);
+	return {
+		schema,
+		table,
+		column
+	};
+};
+const matchesTarget = (target, table) => (!target.schema || target.schema === table.schema) && (!target.table || target.table === table.name);
+const isExcluded = (excludes, table) => excludes.includes(table.schema) || excludes.includes(`${table.schema}.${table.name}`);
+//#endregion
+export { isExcluded, matchesTarget, parseTarget };

package/dist/scaffold/ui-fields.js

@@ -0,0 +1,30 @@
+import { keyColumns } from "../db/keys.js";
+import { findField } from "./existing-config.js";
+import { isTenantColumn } from "../infer/tenant.js";
+import { isSoftDeleteColumn } from "./resource-plan.js";
+//#region src/scaffold/ui-fields.ts
+const uiFields = (table, existing, decisions) => {
+	const key = keyColumns(table) ?? [];
+	return table.columns.flatMap((column) => {
+		const declared = existing && findField(existing, column.name);
+		const decided = decisions.find((d) => d.proposal.column === column.name);
+		const resolved = declared ? {
+			name: declared.name,
+			type: declared.type ?? "text",
+			ignored: declared.ignored
+		} : decided && {
+			name: decided.proposal.name,
+			type: decided.proposal.type,
+			ignored: decided.ignored
+		};
+		if (!resolved || resolved.ignored) return [];
+		const role = key.includes(column.name) ? "key" : isTenantColumn(column.name) ? "tenant" : isSoftDeleteColumn(table, column.name) ? "softDelete" : "plain";
+		return [{
+			name: resolved.name,
+			type: resolved.type,
+			role
+		}];
+	});
+};
+//#endregion
+export { uiFields };

package/dist/scaffold/ui-file.js

@@ -0,0 +1,40 @@
+import { humanize, humanizeSingular } from "../infer/names.js";
+import { parseSource } from "./project.js";
+import { methodCalls } from "./existing-config.js";
+import { Node, SyntaxKind } from "ts-morph";
+//#region src/scaffold/ui-file.ts
+const auditField = /^(created|updated)(At|On)$/;
+const longText = /^(notes?|description|body|comment|comments)$/;
+const listSize = 5;
+const listColumns = (fields) => {
+	const plain = fields.filter((f) => f.role === "plain" && f.type !== "json" && !auditField.test(f.name));
+	const scalars = plain.filter((f) => f.type !== "relation" && !longText.test(f.name));
+	const relations = plain.filter((f) => f.type === "relation");
+	const picked = [...scalars.slice(0, listSize), ...scalars.length < 3 ? relations : []].slice(0, listSize);
+	return (picked.length > 0 ? picked : fields.filter((f) => f.role === "key")).map((f) => f.name);
+};
+const viewName = (resource) => `${resource}View`;
+const sectionText = {
+	names: (t) => `.names({ singular: '${humanizeSingular(t.tableName)}', plural: '${humanize(t.tableName)}' })`,
+	list: (t) => `.list((r) => ({ columns: [${listColumns(t.fields).map((n) => `r.${n}`).join(", ")}] }))`
+};
+const lines = (sections, target) => sections.map((s) => `  ${sectionText[s](target)}`);
+const renderUiFile = (target, sections) => [
+	`import { view } from '@protobase/schema'`,
+	`import type { ${target.resource} } from './data'`,
+	"",
+	`export const ${viewName(target.resource)} = view<typeof ${target.resource}>('${target.resource}')`,
+	...lines(sections, target),
+	""
+].join("\n");
+const addUiSections = (text, target, sections) => {
+	const source = parseSource(text);
+	const chain = source.getDescendantsOfKind(SyntaxKind.CallExpression).find((call) => call.getExpression().getText() === "view")?.getFirstAncestor((a) => Node.isVariableDeclaration(a))?.getInitializer();
+	if (!chain || !Node.isCallExpression(chain)) throw new Error("ui.ts has no view(...) export to extend");
+	const missing = sections.filter((s) => methodCalls(chain, s).length === 0);
+	if (missing.length === 0) return text;
+	chain.replaceWithText(`${chain.getText()}\n${lines(missing, target).join("\n")}`);
+	return source.getFullText();
+};
+//#endregion
+export { addUiSections, listColumns, renderUiFile, viewName };

package/dist/serve/app.js

@@ -0,0 +1,30 @@
+import { isApiPath } from "../bundle/manifest.js";
+import { serveStaticSite } from "./static-site.js";
+import { Hono } from "hono";
+import { logger } from "hono/logger";
+import { configExports, createAdmin } from "@protobase/server";
+//#region src/serve/app.ts
+const createServeApp = ({ project, db, requestLog, site }) => {
+	const { resources, views, pages, userMenu } = configExports(project.config);
+	const admin = createAdmin({
+		resources,
+		views,
+		pages,
+		...userMenu && { userMenu },
+		db,
+		authenticate: project.authenticate,
+		...project.auth && { auth: project.auth },
+		options: {
+			onUnhandledError: (error) => console.error(error),
+			...project.options
+		}
+	});
+	const app = new Hono();
+	if (requestLog) app.use(logger());
+	app.get("/health", (c) => c.json({ status: "ok" }));
+	if (site) app.use("*", (c, next) => isApiPath(site.api, c.req.path) ? next() : serveStaticSite(site, c.req.raw));
+	app.route("/", admin);
+	return app;
+};
+//#endregion
+export { createServeApp };

package/dist/serve/bundle-version.js

@@ -0,0 +1,16 @@
+import { manifestFile } from "../bundle/manifest.js";
+import { protobaseVersion } from "../version/version.js";
+import { bundleVersionProblem } from "../version/compatibility.js";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+//#region src/serve/bundle-version.ts
+const checkBundleVersion = async (configFile, runtimeVersion = protobaseVersion) => {
+	const file = path.join(path.dirname(configFile), manifestFile);
+	if (!existsSync(file)) throw new Error(`${file} is missing; serve the config module of a bundle folder from \`protobase build\``);
+	const manifest = JSON.parse(await readFile(file, "utf8"));
+	const problem = bundleVersionProblem(runtimeVersion, manifest?.protobase);
+	if (problem) throw new Error(`${file}: ${problem}`);
+};
+//#endregion
+export { checkBundleVersion };

package/dist/serve/env.js

@@ -0,0 +1,13 @@
+//#region src/serve/env.ts
+const defaultPort = 8787;
+const readServeEnv = (env) => {
+	const port = env.PORT ? Number(env.PORT) : defaultPort;
+	if (!Number.isInteger(port) || port < 0 || port > 65535) throw new Error(`PORT must be a port number, not "${env.PORT}"`);
+	return {
+		port,
+		databaseUrl: env.DATABASE_URL || void 0,
+		requestLog: Boolean(env.REQUEST_LOG)
+	};
+};
+//#endregion
+export { defaultPort, readServeEnv };

package/dist/serve/host-module-ids.js

@@ -0,0 +1,21 @@
+//#region src/serve/host-module-ids.ts
+const hostModuleIds = [
+	"@protobase/schema",
+	"@protobase/layout",
+	"@protobase/layout/jsx-runtime",
+	"@protobase/query",
+	"@protobase/server",
+	"kysely",
+	"kysely/helpers/postgres",
+	"pg",
+	"postgres",
+	"better-auth",
+	"hono",
+	"jose",
+	"zod",
+	"aip-parsers",
+	"@hono/node-server",
+	"@scalar/hono-api-reference"
+];
+//#endregion
+export { hostModuleIds };

package/dist/serve/host-modules.js

@@ -0,0 +1,49 @@
+import * as postgres$1 from "postgres";
+import * as schema from "@protobase/schema";
+import * as nodeServer from "@hono/node-server";
+import * as pg$1 from "pg";
+import * as kysely from "kysely";
+import * as hono from "hono";
+import * as server from "@protobase/server";
+import * as apiReference from "@scalar/hono-api-reference";
+import * as aipParsers from "aip-parsers";
+import * as betterAuth from "better-auth";
+import * as jose from "jose";
+import * as kyselyPostgres from "kysely/helpers/postgres";
+import * as zod from "zod";
+import * as layout from "@protobase/layout";
+import * as query from "@protobase/query";
+//#region src/serve/host-modules.ts
+const hostModules = {
+	"@protobase/schema": schema,
+	"@protobase/layout": layout,
+	"@protobase/layout/jsx-runtime": layout.jsxRuntime,
+	"@protobase/query": query,
+	"@protobase/server": server,
+	kysely,
+	"kysely/helpers/postgres": kyselyPostgres,
+	pg: pg$1,
+	postgres: postgres$1,
+	"better-auth": betterAuth,
+	hono,
+	jose,
+	zod,
+	"aip-parsers": aipParsers,
+	"@hono/node-server": nodeServer,
+	"@scalar/hono-api-reference": apiReference
+};
+const provideHostModules = () => {
+	const bun = globalThis.Bun;
+	if (!bun) return;
+	bun.plugin({
+		name: "protobase-host-modules",
+		setup: (build) => {
+			for (const [id, exports] of Object.entries(hostModules)) build.module(id, () => ({
+				exports,
+				loader: "object"
+			}));
+		}
+	});
+};
+//#endregion
+export { provideHostModules };