@protobase/cli 0.0.0-stage → 0.1.1

package/dist/build/packages/package-tree.js

@@ -0,0 +1,53 @@
+import { findPackageDir, readPackageJson } from "./package-dir.js";
+import { isPlatformPackage, packageTargets } from "./targets.js";
+import { realpath } from "node:fs/promises";
+//#region src/build/packages/package-tree.ts
+const lookupPath = (dest, name) => {
+	const parts = dest.split("/node_modules/");
+	return [...parts.map((_, i) => [...parts.slice(0, parts.length - i), name].join("/node_modules/")), name];
+};
+const runsOnTarget = (json) => !isPlatformPackage(json) || packageTargets(json).length > 0;
+const packageTree = async (imports) => {
+	const placed = /* @__PURE__ */ new Map();
+	const tree = [];
+	const place = (pkg) => {
+		placed.set(pkg.dest, pkg.dir);
+		tree.push(pkg);
+	};
+	for (const imported of imports) {
+		const { name } = imported;
+		const dir = await realpath(imported.dir);
+		const there = placed.get(name);
+		if (there !== void 0 && there !== dir) throw new Error(`The config imports two installs of ${name}: ${there} and ${dir}`);
+		const json = await readPackageJson(dir);
+		if (there === void 0 && runsOnTarget(json)) place({
+			name,
+			dir,
+			dest: name,
+			json
+		});
+	}
+	for (let i = 0; i < tree.length; i++) {
+		const parent = tree[i];
+		const optional = parent.json.optionalDependencies ?? {};
+		for (const name of /* @__PURE__ */ new Set([...Object.keys(parent.json.dependencies ?? {}), ...Object.keys(optional)])) {
+			const dir = await findPackageDir(name, parent.dir);
+			if (!dir && name in optional) continue;
+			if (!dir) throw new Error(`${name}, which ${parent.name} needs, is not installed`);
+			const json = await readPackageJson(dir);
+			if (!runsOnTarget(json)) continue;
+			const candidates = lookupPath(parent.dest, name);
+			const found = candidates.find((dest) => placed.has(dest));
+			if (found !== void 0 && placed.get(found) === dir) continue;
+			place({
+				name,
+				dir,
+				dest: found === void 0 ? name : candidates[0],
+				json
+			});
+		}
+	}
+	return tree;
+};
+//#endregion
+export { packageTree };

package/dist/build/packages/targets.js

@@ -0,0 +1,38 @@
+//#region src/build/packages/targets.ts
+const bundleTargets = ["linux-x64", "linux-arm64"];
+const isTarget = (platform) => bundleTargets.includes(platform);
+const runImageLibraries = /* @__PURE__ */ new Set([
+	"ld-linux-x86-64.so.2",
+	"ld-linux-aarch64.so.1",
+	"libc.so.6",
+	"libm.so.6",
+	"libmvec.so.1",
+	"libdl.so.2",
+	"libpthread.so.0",
+	"librt.so.1",
+	"libresolv.so.2",
+	"libutil.so.1",
+	"libanl.so.1",
+	"libnsl.so.1",
+	"libBrokenLocale.so.1",
+	"libthread_db.so.1",
+	"libc_malloc_debug.so.0",
+	"libnss_compat.so.2",
+	"libnss_dns.so.2",
+	"libnss_files.so.2",
+	"libnss_hesiod.so.2",
+	"libstdc++.so.6",
+	"libgcc_s.so.1"
+]);
+const allows = (list, value) => {
+	if (!list?.length) return true;
+	if (list.includes(`!${value}`)) return false;
+	return list.includes(value) || list.every((item) => item.startsWith("!"));
+};
+const isPlatformPackage = (json) => Boolean(json.os?.length || json.cpu?.length || json.libc?.length);
+const packageTargets = (json) => bundleTargets.filter((target) => {
+	const [os, cpu] = target.split("-");
+	return allows(json.os, os) && allows(json.cpu, cpu) && allows(json.libc, "glibc");
+});
+//#endregion
+export { bundleTargets, isPlatformPackage, isTarget, packageTargets, runImageLibraries };

package/dist/build/serve-runtime.js

@@ -0,0 +1,16 @@
+import { moduleFile } from "../module-file.js";
+import { viteBundle } from "./vite-bundle.js";
+import { fileURLToPath } from "node:url";
+//#region src/build/serve-runtime.ts
+const cliRoot = fileURLToPath(new URL("../..", import.meta.url));
+const serveMain = moduleFile("../serve/main", import.meta.url);
+const buildServeRuntime = async ({ outFile }) => {
+	await viteBundle({
+		root: cliRoot,
+		entry: serveMain,
+		outFile,
+		plugins: []
+	});
+};
+//#endregion
+export { buildServeRuntime };

package/dist/build/ui-bundle.js

@@ -0,0 +1,33 @@
+import { adminAppDir } from "../project/admin-app.js";
+import { projectUiPlugin } from "../project/project-ui.js";
+import { build } from "vite";
+import tailwindcss from "@tailwindcss/vite";
+import react from "@vitejs/plugin-react";
+//#region src/build/ui-bundle.ts
+const buildUiBundle = async ({ outDir, projectDir }) => {
+	const nodeEnv = process.env.NODE_ENV;
+	process.env.NODE_ENV = "production";
+	await build({
+		configFile: false,
+		root: adminAppDir,
+		base: "/",
+		mode: "production",
+		publicDir: false,
+		logLevel: "warn",
+		plugins: [
+			projectUiPlugin(projectDir),
+			react(),
+			tailwindcss()
+		],
+		build: {
+			outDir,
+			emptyOutDir: true,
+			chunkSizeWarningLimit: 4096
+		}
+	}).finally(() => {
+		if (nodeEnv === void 0) delete process.env.NODE_ENV;
+		else process.env.NODE_ENV = nodeEnv;
+	});
+};
+//#endregion
+export { buildUiBundle };

package/dist/build/vite-bundle.js

@@ -0,0 +1,36 @@
+import path from "node:path";
+import { build } from "vite";
+//#region src/build/vite-bundle.ts
+const viteBundle = async ({ root, entry, outFile, plugins }) => {
+	await build({
+		configFile: false,
+		root,
+		publicDir: false,
+		logLevel: "warn",
+		plugins,
+		oxc: { jsx: { development: false } },
+		ssr: {
+			noExternal: true,
+			target: "node"
+		},
+		build: {
+			ssr: entry,
+			outDir: path.dirname(outFile),
+			emptyOutDir: false,
+			copyPublicDir: false,
+			minify: false,
+			target: "esnext",
+			rolldownOptions: {
+				external: ["pg-native"],
+				output: {
+					entryFileNames: path.basename(outFile),
+					format: "es",
+					codeSplitting: false,
+					banner: "// @bun"
+				}
+			}
+		}
+	});
+};
+//#endregion
+export { viteBundle };

package/dist/bundle/manifest.js

@@ -0,0 +1,35 @@
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+//#region src/bundle/manifest.ts
+const manifestFile = "protobase.bundle.json";
+const isApiPath = (api, pathname) => api.some((prefix) => pathname === prefix || pathname.startsWith(`${prefix}/`));
+const bundleBasePath = "/api/v1";
+const bundleLayout = {
+	server: "protobase.config.js",
+	public: "public",
+	spa: "index.html",
+	api: ["/api"]
+};
+const bundleNodeModules = "node_modules";
+const isStringList = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+const parseManifest = (value, file) => {
+	const manifest = value;
+	if (manifest?.version !== 2) throw new Error(`${file} is not a version 2 bundle manifest; rebuild it with \`protobase build\``);
+	const { server, public: publicDir, api, spa, nodeModules } = manifest;
+	if (typeof server !== "string" || typeof publicDir !== "string" || typeof spa !== "string" || !isStringList(api)) throw new Error(`${file} needs server, public and spa paths and an api list`);
+	if (nodeModules !== void 0 && typeof nodeModules !== "string") throw new Error(`${file} has a nodeModules that is no path`);
+	return {
+		version: 2,
+		server,
+		public: publicDir,
+		api,
+		spa,
+		...nodeModules === void 0 ? {} : { nodeModules }
+	};
+};
+const readManifest = async (bundleDir) => {
+	const file = path.join(bundleDir, manifestFile);
+	return parseManifest(JSON.parse(await readFile(file, "utf8")), file);
+};
+//#endregion
+export { bundleBasePath, bundleLayout, bundleNodeModules, isApiPath, manifestFile, parseManifest, readManifest };

package/dist/db/connect.js

@@ -0,0 +1,18 @@
+import postgres from "postgres";
+//#region src/db/connect.ts
+const connect = (url, options = {}) => postgres(url, {
+	max: 1,
+	...options.connectTimeout && { connect_timeout: options.connectTimeout },
+	onnotice: () => {},
+	connection: { default_transaction_read_only: true }
+});
+const resolveConnectionUrl = (arg, envName) => {
+	if (arg && envName) throw new Error("Pass either a connection string or --env, not both");
+	if (arg) return arg;
+	if (!envName) throw new Error("Pass a connection string or --env <VARIABLE>");
+	const value = process.env[envName];
+	if (!value) throw new Error(`Environment variable ${envName} is not set`);
+	return value;
+};
+//#endregion
+export { connect, resolveConnectionUrl };

package/dist/db/introspect.js

@@ -0,0 +1,47 @@
+import { tableKey } from "./model.js";
+import { selectChecks, selectColumns, selectForeignKeys, selectIndexes } from "./queries.js";
+//#region src/db/introspect.ts
+const byTable = (rows) => {
+	const groups = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const key = tableKey({
+			schema: row.schema,
+			name: row.table
+		});
+		groups.set(key, [...groups.get(key) ?? [], row]);
+	}
+	return groups;
+};
+const introspect = async (sql) => {
+	const [columns, foreignKeys, checks, indexes] = await Promise.all([
+		selectColumns(sql),
+		selectForeignKeys(sql),
+		selectChecks(sql),
+		selectIndexes(sql)
+	]);
+	const fks = byTable(foreignKeys);
+	const chks = byTable(checks);
+	const idxs = byTable(indexes);
+	return [...byTable(columns)].map(([key, rows]) => ({
+		schema: rows[0].schema,
+		name: rows[0].table,
+		columns: rows.map(({ schema, table, enumValues, defaultExpr, ...column }) => ({
+			...column,
+			enumValues: enumValues ?? [],
+			...defaultExpr !== null && { defaultExpr }
+		})),
+		foreignKeys: (fks.get(key) ?? []).map(({ columns, refSchema, refTable, refColumns }) => ({
+			columns,
+			refSchema,
+			refTable,
+			refColumns
+		})),
+		checks: (chks.get(key) ?? []).map(({ columns, definition }) => ({
+			columns,
+			definition
+		})),
+		indexes: (idxs.get(key) ?? []).map(({ schema, table, ...index }) => index)
+	}));
+};
+//#endregion
+export { introspect };

package/dist/db/keys.js

@@ -0,0 +1,15 @@
+//#region src/db/keys.ts
+const plainColumns = (columns) => columns.every((column) => column !== null) ? columns : void 0;
+const keyColumns = (table) => {
+	const primary = table.indexes.find((index) => index.primary);
+	if (primary) return plainColumns(primary.columns);
+	const notNull = new Set(table.columns.filter((column) => column.notNull).map((column) => column.name));
+	return table.indexes.filter((index) => index.unique && !index.partial).map((index) => plainColumns(index.columns)).find((columns) => columns && columns.every((column) => notNull.has(column)));
+};
+const isUniqueSet = (table, columns) => table.indexes.some((index) => {
+	const indexed = plainColumns(index.columns);
+	return index.unique && !index.partial && indexed && indexed.every((column) => columns.includes(column));
+});
+const leadingIndex = (table, column, tenantColumn) => table.indexes.find((index) => !index.partial && (index.columns[0] === column || tenantColumn !== void 0 && index.columns[0] === tenantColumn && index.columns[1] === column));
+//#endregion
+export { isUniqueSet, keyColumns, leadingIndex };

package/dist/db/model.js

@@ -0,0 +1,4 @@
+//#region src/db/model.ts
+const tableKey = (table) => `${table.schema}.${table.name}`;
+//#endregion
+export { tableKey };

package/dist/db/queries.js

@@ -0,0 +1,62 @@
+//#region src/db/queries.ts
+const userTables = `
+  c.relkind in ('r', 'p')
+  and n.nspname not in ('pg_catalog', 'information_schema', 'pg_toast')
+  and n.nspname not like 'pg_temp%'
+`;
+const selectColumns = (sql) => sql`
+  select n.nspname as schema, c.relname as table, a.attname as name, a.attnum::int as position,
+    bt.typname as "typeName", format_type(a.atttypid, a.atttypmod) as formatted,
+    (bt.typtype = 'e') as "isEnum",
+    (select array_agg(e.enumlabel::text order by e.enumsortorder) from pg_enum e where e.enumtypid = bt.oid) as "enumValues",
+    a.attnotnull as "notNull", (a.attidentity <> '') as identity, (a.attidentity = 'a') as "identityAlways", (a.attgenerated <> '') as generated,
+    pg_get_expr(d.adbin, d.adrelid) as "defaultExpr"
+  from pg_attribute a
+  join pg_class c on c.oid = a.attrelid
+  join pg_namespace n on n.oid = c.relnamespace
+  join pg_type t on t.oid = a.atttypid
+  join pg_type bt on bt.oid = case when t.typtype = 'd' then t.typbasetype else t.oid end
+  left join pg_attrdef d on d.adrelid = a.attrelid and d.adnum = a.attnum
+  where ${sql.unsafe(userTables)} and a.attnum > 0 and not a.attisdropped
+  order by n.nspname, c.relname, a.attnum
+`;
+const selectForeignKeys = (sql) => sql`
+  select n.nspname as schema, c.relname as table,
+    (select array_agg(a.attname::text order by k.ord) from unnest(con.conkey) with ordinality k(attnum, ord)
+      join pg_attribute a on a.attrelid = con.conrelid and a.attnum = k.attnum) as columns,
+    rn.nspname as "refSchema", rc.relname as "refTable",
+    (select array_agg(a.attname::text order by k.ord) from unnest(con.confkey) with ordinality k(attnum, ord)
+      join pg_attribute a on a.attrelid = con.confrelid and a.attnum = k.attnum) as "refColumns"
+  from pg_constraint con
+  join pg_class c on c.oid = con.conrelid
+  join pg_namespace n on n.oid = c.relnamespace
+  join pg_class rc on rc.oid = con.confrelid
+  join pg_namespace rn on rn.oid = rc.relnamespace
+  where con.contype = 'f' and ${sql.unsafe(userTables)}
+`;
+const selectChecks = (sql) => sql`
+  select n.nspname as schema, c.relname as table,
+    (select array_agg(a.attname::text order by k.ord) from unnest(con.conkey) with ordinality k(attnum, ord)
+      join pg_attribute a on a.attrelid = con.conrelid and a.attnum = k.attnum) as columns,
+    pg_get_constraintdef(con.oid) as definition
+  from pg_constraint con
+  join pg_class c on c.oid = con.conrelid
+  join pg_namespace n on n.oid = c.relnamespace
+  where con.contype = 'c' and con.conkey is not null and ${sql.unsafe(userTables)}
+`;
+const selectIndexes = (sql) => sql`
+  select n.nspname as schema, c.relname as table, ic.relname as name,
+    (select array_agg(case when k.attnum = 0 then null else a.attname::text end order by k.ord)
+      from unnest(i.indkey::int2[]) with ordinality k(attnum, ord)
+      left join pg_attribute a on a.attrelid = i.indrelid and a.attnum = k.attnum
+      where k.ord <= i.indnkeyatts) as columns,
+    i.indisunique as unique, i.indisprimary as primary, (i.indpred is not null) as partial, am.amname as method
+  from pg_index i
+  join pg_class c on c.oid = i.indrelid
+  join pg_namespace n on n.oid = c.relnamespace
+  join pg_class ic on ic.oid = i.indexrelid
+  join pg_am am on am.oid = ic.relam
+  where i.indisvalid and ${sql.unsafe(userTables)}
+`;
+//#endregion
+export { selectChecks, selectColumns, selectForeignKeys, selectIndexes };

package/dist/dev/check-database.js

@@ -0,0 +1,38 @@
+import { connect } from "../db/connect.js";
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+//#region src/dev/check-database.ts
+const describeTarget = (url) => {
+	const { hostname, port, pathname } = new URL(url);
+	return `${hostname}:${port || 5432}${pathname}`;
+};
+const startHint = async (projectDir) => {
+	const manifest = await readFile(path.join(projectDir, "package.json"), "utf8").catch((error) => {
+		if (error.code === "ENOENT") return void 0;
+		throw error;
+	});
+	if (!manifest) return "";
+	const { name, scripts } = JSON.parse(manifest);
+	if (!scripts?.["db:up"]) return "";
+	return `\nStart it with: pnpm --filter ${name} db:up`;
+};
+const reasons = {
+	ECONNREFUSED: "the connection was refused, so no Postgres is listening there",
+	ENOTFOUND: "the host name does not resolve",
+	CONNECT_TIMEOUT: "the connection timed out",
+	ETIMEDOUT: "the connection timed out",
+	"28P01": "the password was rejected",
+	"28000": "the user was rejected",
+	"3D000": "the database does not exist"
+};
+const checkDatabase = async (url, projectDir) => {
+	const sql = connect(url, { connectTimeout: 3 });
+	const failure = await sql`select 1`.then(() => void 0, (error) => {
+		if (!error.code || !(error.code in reasons)) throw error;
+		return reasons[error.code];
+	});
+	await sql.end();
+	if (failure) throw new Error(`Cannot reach the database at ${describeTarget(url)}: ${failure}.${await startHint(projectDir)}`);
+};
+//#endregion
+export { checkDatabase };

package/dist/dev/create-db.js

@@ -0,0 +1,13 @@
+import { createPgDb } from "../project/pg-db.js";
+import { createRequire } from "node:module";
+import path from "node:path";
+//#region src/dev/create-db.ts
+const sharedDb = (projectDir, url) => {
+	const store = globalThis;
+	if (store.__protobaseDb) return store.__protobaseDb;
+	const load = createRequire(path.join(projectDir, "package.json"));
+	store.__protobaseDb = createPgDb(load("pg"), url);
+	return store.__protobaseDb;
+};
+//#endregion
+export { sharedDb };

package/dist/dev/entry.d.ts

@@ -0,0 +1,4 @@
+//#region src/dev/entry.d.ts
+declare const _default: import("hono/hono-base").HonoBase<import("hono/types").BlankEnv, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema, "/">, "/", "/">;
+//#endregion
+export { _default as default };

package/dist/dev/entry.js

@@ -0,0 +1,32 @@
+import { loadProject, projectDb } from "./project.js";
+import { Hono } from "hono";
+import { configExports, createAdmin, hasUsers } from "@protobase/server";
+//#region src/dev/entry.ts
+const projectDir = process.env.PROTOBASE_PROJECT;
+const project = await loadProject(projectDir);
+const db = projectDb(project, projectDir);
+const { resources, views, pages, userMenu } = configExports(project.exports);
+if (!project.authenticate) throw new Error("No authenticator: export `authenticate` (and `auth`) from protobase.config.ts; see https://docs.protobase.net/reference/auth/");
+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
+	}
+});
+var entry_default = new Hono().route("/", admin);
+const store = globalThis;
+if (project.auth && !store.__protobaseNoUsersShown) {
+	store.__protobaseNoUsersShown = true;
+	hasUsers(project.auth).then((any) => {
+		if (!any) console.log("No users yet. Create the first admin with: protobase users create you@example.com");
+	}, (error) => console.error(`Could not check for users, is the auth schema migrated? ${error.message}`));
+}
+//#endregion
+export { entry_default as default };

package/dist/dev/env.js

@@ -0,0 +1,15 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+//#region src/dev/env.ts
+const loadNearestEnvFile = (from) => {
+	for (let dir = from;; dir = path.dirname(dir)) {
+		const file = path.join(dir, ".env");
+		if (existsSync(file)) {
+			process.loadEnvFile(file);
+			return file;
+		}
+		if (path.dirname(dir) === dir) return void 0;
+	}
+};
+//#endregion
+export { loadNearestEnvFile };

package/dist/dev/hosts.js

@@ -0,0 +1,4 @@
+//#region src/dev/hosts.ts
+const parseHosts = (value) => (value ?? "").split(",").map((host) => host.trim()).filter(Boolean);
+//#endregion
+export { parseHosts };

package/dist/dev/project.js

@@ -0,0 +1,39 @@
+import { conventionConfig } from "../project/convention.js";
+import { sharedDb } from "./create-db.js";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { readdir } from "node:fs/promises";
+//#region src/dev/project.ts
+const load = (file) => import(
+	/* @vite-ignore */
+	`/@fs${file}`
+);
+const conventionExports = async (projectDir) => {
+	const configDir = path.join(projectDir, "config");
+	const index = path.join(configDir, "index.ts");
+	if (!existsSync(index)) throw new Error(`No config/index.ts in ${projectDir}; run \`protobase scaffold\` or add a protobase.config.ts`);
+	const indexExports = await load(index);
+	const dirs = (await readdir(configDir, { withFileTypes: true })).filter((entry) => entry.isDirectory());
+	const uiModules = [];
+	for (const { name } of dirs) {
+		const ui = path.join(configDir, name, "ui.ts");
+		if (existsSync(ui)) uiModules.push([name, await load(ui)]);
+	}
+	return conventionConfig(indexExports, uiModules);
+};
+const loadProject = async (projectDir) => {
+	const file = path.join(projectDir, "protobase.config.ts");
+	const custom = existsSync(file) ? (await load(file)).default ?? {} : {};
+	return {
+		...custom,
+		exports: custom.config ?? await conventionExports(projectDir)
+	};
+};
+const projectDb = (project, projectDir) => {
+	if (project.db) return project.db;
+	const url = process.env.PROTOBASE_DATABASE_URL;
+	if (!url) throw new Error("No database: set DATABASE_URL (or pass --env) or export `db` from protobase.config.ts");
+	return sharedDb(projectDir, url);
+};
+//#endregion
+export { loadProject, projectDb };

package/dist/dev/run.js

@@ -0,0 +1,88 @@
+import { moduleFile } from "../module-file.js";
+import { layoutCheck } from "../build/layout-check.js";
+import { adminAppDir, adminAppMain, uiPackageDir } from "../project/admin-app.js";
+import { projectUiPlugin } from "../project/project-ui.js";
+import { loadNearestEnvFile } from "./env.js";
+import { checkDatabase } from "./check-database.js";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { createServer, searchForWorkspaceRoot } from "vite";
+import tailwindcss from "@tailwindcss/vite";
+import react from "@vitejs/plugin-react";
+import devServer from "@hono/vite-dev-server";
+//#region src/dev/run.ts
+const entry = moduleFile("./entry", import.meta.url);
+const requireAppFiles = (appDir) => {
+	const missing = ["index.html", adminAppMain].filter((file) => !existsSync(path.join(appDir, file)));
+	if (missing.length > 0) throw new Error(`The admin app is missing ${missing.join(", ")} in ${appDir}; \`protobase dev\` serves the app from there`);
+};
+const reloadOnProjectChange = (projectDir) => ({
+	name: "protobase-project-reload",
+	handleHotUpdate: ({ file, server }) => {
+		if (file.startsWith(`${projectDir}${path.sep}`) && !file.includes(`${path.sep}node_modules${path.sep}`)) server.environments.ssr.moduleGraph.invalidateAll();
+	}
+});
+const appDependencies = [
+	"react",
+	"react/jsx-runtime",
+	"react/jsx-dev-runtime",
+	"react-dom",
+	"react-dom/client",
+	"lucide-react",
+	"zod",
+	"@tanstack/react-query",
+	"@tanstack/react-table",
+	"@tanstack/react-virtual",
+	"recharts"
+];
+const runDev = async (options, out) => {
+	loadNearestEnvFile(options.projectDir);
+	const url = process.env[options.envVar];
+	if (!url) throw new Error(`${options.envVar} is not set; add it to .env or pass --env <VARIABLE>`);
+	const appDir = options.appDir ?? adminAppDir;
+	requireAppFiles(appDir);
+	await checkDatabase(url, options.projectDir);
+	process.env.PROTOBASE_PROJECT = options.projectDir;
+	process.env.PROTOBASE_DATABASE_URL = url;
+	const server = await createServer({
+		root: appDir,
+		configFile: false,
+		...options.cacheDir && { cacheDir: options.cacheDir },
+		optimizeDeps: { include: appDependencies },
+		server: {
+			port: options.port,
+			strictPort: true,
+			...options.allowedHosts.length > 0 && { allowedHosts: options.allowedHosts },
+			fs: { allow: [
+				searchForWorkspaceRoot(options.projectDir),
+				uiPackageDir,
+				options.projectDir
+			] }
+		},
+		plugins: [
+			reloadOnProjectChange(options.projectDir),
+			projectUiPlugin(options.projectDir),
+			layoutCheck(),
+			react(),
+			tailwindcss(),
+			devServer({
+				entry,
+				exclude: [/^(?!\/api(\/|\?|$)).*/],
+				injectClientScript: false
+			})
+		]
+	});
+	await server.listen();
+	await server.ssrLoadModule(entry).catch(async (error) => {
+		await server.close();
+		throw error;
+	});
+	const address = server.httpServer?.address();
+	const port = typeof address === "object" && address ? address.port : options.port;
+	out(`protobase dev ready at http://localhost:${port}\n`);
+	out(`  project  ${options.projectDir}\n  api      http://localhost:${port}/api/v1 (docs at /api/docs)\n`);
+	out("  login    sign in with a user created by `protobase users create`\n");
+	return server;
+};
+//#endregion
+export { runDev };