@protobase/cli 0.0.0-stage → 0.1.1

package/dist/doctor/check.js

@@ -0,0 +1,76 @@
+import { tableKey } from "../db/model.js";
+import { isUniqueSet, keyColumns, leadingIndex } from "../db/keys.js";
+import { checkEnumValues } from "../infer/check-values.js";
+import { typesCompatible } from "../infer/compat.js";
+import { columnDefault } from "../infer/defaults.js";
+import { inferKind } from "../infer/type-map.js";
+//#region src/doctor/check.ts
+const quoteIdent = (name) => /^[a-z_][a-z0-9_]*$/.test(name) ? name : `"${name.replaceAll("\"", "\"\"")}"`;
+const sameValues = (a = [], b = []) => a.length === b.length && a.every((v) => b.includes(v));
+const checkField = (model, table, name) => {
+	const field = model.fields[name];
+	const issues = [];
+	const error = (message, suggestion) => ({
+		severity: "error",
+		resource: model.name,
+		message: `${name}: ${message}`,
+		...suggestion && { suggestion }
+	});
+	const columns = field.relation?.columns ?? [field.column];
+	for (const columnName of columns) if (!table.columns.some((c) => c.name === columnName)) issues.push(error(`column "${columnName}" does not exist in ${tableKey(table)}`));
+	const column = table.columns.find((c) => c.name === columns[0]);
+	if (!column) return issues;
+	const kind = inferKind(column, checkEnumValues(table.checks, column.name));
+	if (!typesCompatible(field.type, kind.type)) issues.push(error(`declared ${field.type}, but ${column.name} is ${column.formatted}`));
+	else if (field.type === "enum" && kind.type === "enum" && !sameValues(field.enumValues, kind.enumValues)) issues.push({
+		severity: "warning",
+		resource: model.name,
+		message: `${name}: enum values differ from the database (${kind.enumValues?.join(", ")})`
+	});
+	const declared = field.default && "db" in field.default;
+	const fallback = columnDefault(column, kind).kind;
+	if (fallback === "db" && !field.default) issues.push({
+		severity: "warning",
+		resource: model.name,
+		message: `${name}: ${column.name} has a database default; add .dbDefault() (or .default(value))`
+	});
+	if (declared && fallback !== "db") issues.push({
+		severity: "warning",
+		resource: model.name,
+		message: `${name}: declared .dbDefault() but ${column.name} has no default the database computes`
+	});
+	if (field.filterable && !leadingIndex(table, column.name, model.tenant && model.fields[model.tenant]?.column)) issues.push({
+		severity: "warning",
+		resource: model.name,
+		message: `${name}: filterable but ${column.name} has no index`,
+		suggestion: `CREATE INDEX ON ${quoteIdent(table.schema)}.${quoteIdent(table.name)} (${quoteIdent(column.name)});`
+	});
+	return issues;
+};
+const checkKey = (model, table) => {
+	if (!keyColumns(table)) return [{
+		severity: "error",
+		resource: model.name,
+		message: `${tableKey(table)} has no primary key or unique NOT NULL index`,
+		suggestion: `ALTER TABLE ${quoteIdent(table.schema)}.${quoteIdent(table.name)} ADD PRIMARY KEY (...);`
+	}];
+	const columns = model.primaryKey.map((name) => model.fields[name]?.column);
+	if (columns.some((c) => c === void 0) || isUniqueSet(table, columns)) return [];
+	return [{
+		severity: "error",
+		resource: model.name,
+		message: `primary key (${columns.join(", ")}) is not backed by a unique index`
+	}];
+};
+const checkResource = (model, tables) => {
+	const schema = model.table.schema ?? "public";
+	const table = tables.find((t) => t.schema === schema && t.name === model.table.name);
+	if (!table) return [{
+		severity: "error",
+		resource: model.name,
+		message: `table ${schema}.${model.table.name} does not exist`
+	}];
+	return [...Object.keys(model.fields).flatMap((name) => checkField(model, table, name)), ...checkKey(model, table)];
+};
+//#endregion
+export { checkResource };

package/dist/doctor/load-config.js

@@ -0,0 +1,10 @@
+import { importProjectFile } from "../project/import-project-file.js";
+import path from "node:path";
+//#region src/doctor/load-config.ts
+const isResource = (value) => typeof value === "object" && value !== null && "toModel" in value && "ignoredColumns" in value && typeof value.toModel === "function";
+const loadResourceModels = async (configDir) => {
+	const exports = await importProjectFile(path.resolve(configDir, "index.ts"));
+	return Object.values(exports).filter(isResource).map((resource) => resource.toModel());
+};
+//#endregion
+export { loadResourceModels };

package/dist/doctor/run.js

@@ -0,0 +1,22 @@
+import { connect } from "../db/connect.js";
+import { introspect } from "../db/introspect.js";
+import { checkResource } from "./check.js";
+import { loadResourceModels } from "./load-config.js";
+//#region src/doctor/run.ts
+const format = (issue) => `  ${issue.severity.padEnd(7)} ${issue.resource}: ${issue.message}${issue.suggestion ? `\n          fix: ${issue.suggestion}` : ""}\n`;
+const runDoctor = async (options, out) => {
+	const models = await loadResourceModels(options.configDir);
+	if (models.length === 0) throw new Error(`No resources exported from ${options.configDir}/index.ts`);
+	const sql = connect(options.url);
+	const tables = await introspect(sql).finally(() => sql.end());
+	const issues = models.flatMap((model) => checkResource(model, tables));
+	for (const issue of issues) out(format(issue));
+	const errors = issues.filter((i) => i.severity === "error").length;
+	out(`Checked ${models.length} resources: ${errors} errors, ${issues.length - errors} warnings.\n`);
+	return {
+		errors,
+		warnings: issues.length - errors
+	};
+};
+//#endregion
+export { runDoctor };

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { run } from "./main.js";
+export { run };

package/dist/index.js

@@ -0,0 +1,2 @@
+import { run } from "./main.js";
+export { run };

package/dist/infer/check-values.js

@@ -0,0 +1,14 @@
+//#region src/infer/check-values.ts
+const literal = /'((?:[^']|'')*)'(?:::[\w ]+)?/g;
+const parseAnyArray = (definition) => {
+	const match = /= ANY \(\(?ARRAY\[(.+)\]\)/.exec(definition);
+	if (!match) return void 0;
+	const list = match[1];
+	if (list.replace(literal, "").replace(/[\s,]/g, "") !== "") return void 0;
+	return [...list.matchAll(literal)].map((m) => m[1].replaceAll("''", "'"));
+};
+const checkEnumValues = (checks, column) => {
+	return checks.filter((check) => check.columns.length === 1 && check.columns[0] === column).map((check) => parseAnyArray(check.definition)).find((values) => values);
+};
+//#endregion
+export { checkEnumValues };

package/dist/infer/compat.js

@@ -0,0 +1,17 @@
+//#region src/infer/compat.ts
+const relationTargets = [
+	"integer",
+	"bigint",
+	"uuid",
+	"text"
+];
+const typesCompatible = (declared, base) => {
+	if (declared === base) return true;
+	if (declared === "relation") return relationTargets.includes(base);
+	if (declared === "currency" || declared === "country") return base === "text";
+	if (declared === "enum") return base === "text";
+	if (declared === "text") return base === "enum";
+	return false;
+};
+//#endregion
+export { typesCompatible };

package/dist/infer/default-column.js

@@ -0,0 +1,12 @@
+import { f, resource } from "@protobase/schema";
+//#region src/infer/default-column.ts
+const cache = /* @__PURE__ */ new Map();
+const defaultColumn = (fieldName) => {
+	const cached = cache.get(fieldName);
+	if (cached) return cached;
+	const column = resource("probe").table("probe").fields({ [fieldName]: f.text() }).primaryKey((r) => r[fieldName]).toModel().fields[fieldName].column;
+	cache.set(fieldName, column);
+	return column;
+};
+//#endregion
+export { defaultColumn };

package/dist/infer/defaults.js

@@ -0,0 +1,28 @@
+//#region src/infer/defaults.ts
+const quoted = /^\(?'((?:[^']|'')*)'(?:::[\w. "\[\]]+)?\)?$/;
+const number = /^\(?(-?\d+(?:\.\d+)?)\)?(?:::\w+)?$/;
+const parseDefault = (expression, kind) => {
+	const text = expression.trim();
+	if (kind.type === "boolean") return text === "true" ? true : text === "false" ? false : void 0;
+	const quote = quoted.exec(text)?.[1]?.replaceAll("''", "'");
+	const digits = number.exec(text)?.[1];
+	if (kind.type === "integer") {
+		const value = digits ?? quote;
+		return value !== void 0 && Number.isInteger(Number(value)) ? Number(value) : void 0;
+	}
+	if (kind.type === "bigint" || kind.type === "decimal") return digits ?? quote;
+	if (kind.type === "json") return void 0;
+	return quote;
+};
+const columnDefault = (column, kind) => {
+	if (column.generated || column.identityAlways) return { kind: "owned" };
+	if (column.identity) return { kind: "db" };
+	if (column.defaultExpr === void 0) return { kind: "none" };
+	const value = kind.type === "json" ? void 0 : parseDefault(column.defaultExpr, kind);
+	return value === void 0 ? { kind: "db" } : {
+		kind: "literal",
+		value
+	};
+};
+//#endregion
+export { columnDefault, parseDefault };

package/dist/infer/names.js

@@ -0,0 +1,28 @@
+//#region src/infer/names.ts
+const words = (name) => name.split(/[^A-Za-z0-9]+/).filter(Boolean);
+const capitalize = (word) => word.charAt(0).toUpperCase() + word.slice(1);
+const lowerFirst = (word) => word.charAt(0).toLowerCase() + word.slice(1);
+const identifier = (name) => /^[0-9]/.test(name) ? `c${name}` : name;
+const camelCase = (name) => {
+	const parts = words(name);
+	if (parts.length === 0) throw new Error(`Cannot derive a field name from "${name}"`);
+	if (/[a-z]/.test(name) && /[A-Z]/.test(name) && parts.length === 1) return identifier(lowerFirst(parts[0]));
+	const [first, ...rest] = parts.map((part) => part.toLowerCase());
+	return identifier(first + rest.map(capitalize).join(""));
+};
+const singular = (word) => {
+	if (word.endsWith("ies")) return `${word.slice(0, -3)}y`;
+	if (/(sses|xes|ches|shes)$/.test(word)) return word.slice(0, -2);
+	if (word.endsWith("s") && !word.endsWith("ss") && !word.endsWith("us")) return word.slice(0, -1);
+	return word;
+};
+const humanize = (name) => {
+	const parts = words(name.replace(/([a-z0-9])([A-Z])/g, "$1 $2")).map((part) => part.toLowerCase());
+	return capitalize(parts.join(" "));
+};
+const humanizeSingular = (name) => {
+	const parts = humanize(name).split(" ");
+	return [...parts.slice(0, -1), singular(parts.at(-1).toLowerCase())].join(" ").replace(/^./, (c) => c.toUpperCase());
+};
+//#endregion
+export { camelCase, humanize, humanizeSingular, singular };

package/dist/infer/proposal.js

@@ -0,0 +1,68 @@
+import { leadingIndex } from "../db/keys.js";
+import { checkEnumValues } from "./check-values.js";
+import { columnDefault } from "./defaults.js";
+import { inferKind } from "./type-map.js";
+import { defaultColumn } from "./default-column.js";
+import { camelCase } from "./names.js";
+import { isTenantColumn } from "./tenant.js";
+//#region src/infer/proposal.ts
+const columnIndexing = (table, column) => {
+	const tenant = table.columns.find((c) => isTenantColumn(c.name))?.name;
+	const index = leadingIndex(table, column, tenant);
+	return {
+		filterable: Boolean(index),
+		sortable: index?.method === "btree"
+	};
+};
+const relationOf = (table, column, context) => {
+	const fk = table.foreignKeys.find((candidate) => candidate.columns[0] === column);
+	if (!fk) return void 0;
+	const resource = context.resourceNameOf(fk.refSchema, fk.refTable);
+	return fk.columns.length === 1 ? { resource } : {
+		resource,
+		columns: fk.columns
+	};
+};
+const auditColumn = /^(created|inserted|updated|modified)_at$/;
+const isServerManaged = (table, column) => column.identity || auditColumn.test(column.name) || table.indexes.some((index) => index.primary && index.columns.includes(column.name));
+const defaultsOf = (table, column, kind) => {
+	const fallback = columnDefault(column, kind);
+	if (fallback.kind === "owned") return { readOnly: true };
+	if (fallback.kind === "db") return {
+		readOnly: isServerManaged(table, column),
+		dbDefault: true
+	};
+	if (fallback.kind === "literal") return {
+		readOnly: false,
+		defaultValue: fallback.value
+	};
+	return { readOnly: false };
+};
+const proposeField = (table, column, context) => {
+	const kind = inferKind(column, checkEnumValues(table.checks, column.name));
+	const relation = relationOf(table, column.name, context);
+	const name = camelCase(column.name);
+	const defaults = defaultsOf(table, column, kind);
+	return {
+		name,
+		column: column.name,
+		type: relation ? "relation" : kind.type,
+		base: kind.type,
+		...kind.precision !== void 0 && {
+			precision: kind.precision,
+			scale: kind.scale
+		},
+		...kind.enumValues && { enumValues: kind.enumValues },
+		...relation && { relation },
+		optional: !column.notNull,
+		...defaults,
+		readOnly: defaults.readOnly || Boolean(kind.unsupported),
+		...kind.type === "json" ? {
+			filterable: false,
+			sortable: false
+		} : columnIndexing(table, column.name)
+	};
+};
+const needsColumnCall = (proposal) => defaultColumn(proposal.name) !== proposal.column;
+//#endregion
+export { auditColumn, isServerManaged, needsColumnCall, proposeField };

package/dist/infer/render-field.js

@@ -0,0 +1,26 @@
+import { needsColumnCall } from "./proposal.js";
+//#region src/infer/render-field.ts
+const quote = (text) => `'${text.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}'`;
+const literal = (value) => typeof value === "string" ? quote(value) : String(value);
+const base = (p) => {
+	if (p.type === "relation") {
+		const { resource, columns } = p.relation;
+		const call = `f.relation(${quote(resource)})`;
+		return columns ? `${call}.columns([${columns.map(quote).join(", ")}])` : call;
+	}
+	if (p.type === "decimal") return `f.decimal({ precision: ${p.precision}, scale: ${p.scale} })`;
+	if (p.type === "enum") return `f.enum([${(p.enumValues ?? []).map(quote).join(", ")}])`;
+	return `f.${p.type}()`;
+};
+const renderField = (p) => [
+	base(p),
+	p.optional && ".optional()",
+	p.defaultValue !== void 0 && `.default(${literal(p.defaultValue)})`,
+	p.dbDefault && ".dbDefault()",
+	p.readOnly && ".readOnly()",
+	needsColumnCall(p) && `.column(${quote(p.column)})`,
+	p.filterable && ".filterable()",
+	p.sortable && ".sortable()"
+].filter(Boolean).join("");
+//#endregion
+export { quote, renderField };

package/dist/infer/tenant.js

@@ -0,0 +1,5 @@
+//#region src/infer/tenant.ts
+const tenantColumn = /^(organization|tenant)_id$/i;
+const isTenantColumn = (column) => tenantColumn.test(column);
+//#endregion
+export { isTenantColumn };

package/dist/infer/type-map.js

@@ -0,0 +1,52 @@
+//#region src/infer/type-map.ts
+const simple = {
+	int2: "integer",
+	int4: "integer",
+	int8: "bigint",
+	text: "text",
+	varchar: "text",
+	bpchar: "text",
+	name: "text",
+	citext: "text",
+	bool: "boolean",
+	date: "date",
+	timestamp: "timestamp",
+	timestamptz: "timestamp",
+	uuid: "uuid",
+	json: "json",
+	jsonb: "json"
+};
+const numericLimits = (formatted) => {
+	const match = /\((\d+),\s*(\d+)\)/.exec(formatted);
+	if (!match) return {
+		precision: 38,
+		scale: 9
+	};
+	return {
+		precision: Number(match[1]),
+		scale: Number(match[2])
+	};
+};
+const textLike = (typeName) => simple[typeName] === "text";
+const inferKind = (column, checkValues) => {
+	if (column.isEnum) return {
+		type: "enum",
+		enumValues: column.enumValues
+	};
+	if (column.typeName === "numeric") return {
+		type: "decimal",
+		...numericLimits(column.formatted)
+	};
+	const type = simple[column.typeName];
+	if (!type) return {
+		type: "text",
+		unsupported: true
+	};
+	if (checkValues && textLike(column.typeName)) return {
+		type: "enum",
+		enumValues: checkValues
+	};
+	return { type };
+};
+//#endregion
+export { inferKind };

package/dist/main.d.ts

@@ -0,0 +1,4 @@
+import { Command } from "commander";
+//#region src/main.d.ts
+export declare const run: (argv: string[]) => Promise<void | Command>;
+//#endregion

package/dist/main.js

@@ -0,0 +1,84 @@
+import { manifestFile } from "./bundle/manifest.js";
+import { buildDeployBundle } from "./build/deploy-bundle.js";
+import { buildServeRuntime } from "./build/serve-runtime.js";
+import { resolveConnectionUrl } from "./db/connect.js";
+import { parseHosts } from "./dev/hosts.js";
+import { loadNearestEnvFile } from "./dev/env.js";
+import { runDev } from "./dev/run.js";
+import { runDoctor } from "./doctor/run.js";
+import { runScaffold } from "./scaffold/run.js";
+import { serveBundle } from "./serve/serve-bundle.js";
+import { serveBundleDir } from "./serve/serve-dir.js";
+import { registerToken, registerUsers } from "./users/register.js";
+import { statSync } from "node:fs";
+import path from "node:path";
+import { Command, InvalidArgumentError } from "commander";
+//#region src/main.ts
+const out = (text) => process.stdout.write(text);
+const collect = (value, previous) => [...previous, value];
+const uiSection = (value) => {
+	if (value === "names" || value === "list") return value;
+	throw new InvalidArgumentError("expected names or list");
+};
+const collectSection = (value, previous) => [...previous, uiSection(value)];
+const program = new Command("protobase").description("Protobase command line");
+program.command("scaffold").description("Generate or update config/<resource>/data.ts from a Postgres database").argument("[args...]", "connection string (unless --env) followed by an optional target: all, schema, schema.table, schema.table.column").option("--env <variable>", "read the connection string from this environment variable").option("--config <dir>", "config folder", "config").option("--yes", "accept all proposals without asking", false).option("--dry-run", "print a diff instead of writing files", false).option("--ui", "also write config/<resource>/ui.ts (names and list)", false).option("--ui-list", "write only the list section of ui.ts", false).option("--ui-section <name>", "write only this ui.ts section (names or list), repeatable", collectSection, []).option("--exclude <table>", "skip a schema or schema.table, repeatable", collect, []).action(async (args, opts) => {
+	const [first, ...rest] = args;
+	const url = resolveConnectionUrl(opts.env ? void 0 : first, opts.env);
+	const [target, ...extra] = opts.env ? args : rest;
+	if (extra.length > 0) throw new Error(`Unexpected argument "${extra[0]}"`);
+	const ui = opts.ui ? ["names", "list"] : [...opts.uiSection, ...opts.uiList ? ["list"] : []];
+	await runScaffold({
+		url,
+		target,
+		configDir: path.resolve(opts.config),
+		yes: opts.yes,
+		dryRun: opts.dryRun,
+		ui: [...new Set(ui)],
+		excludes: opts.exclude
+	}, out);
+});
+program.command("doctor").description("Check a config folder against the database").argument("[connection]", "connection string").option("--env <variable>", "read the connection string from this environment variable").option("--config <dir>", "config folder", "config").action(async (connection, opts) => {
+	const url = resolveConnectionUrl(connection, opts.env);
+	const { errors } = await runDoctor({
+		url,
+		configDir: path.resolve(opts.config)
+	}, out);
+	if (errors > 0) process.exitCode = 1;
+});
+program.command("dev").description("Serve the admin app and API for the project in the current directory").option("--port <port>", "port for the app and API", "5173").option("--env <variable>", "environment variable holding the database URL", "DATABASE_URL").option("--allowed-hosts <hosts>", "extra Host headers to accept, comma separated; a leading dot matches subdomains (.trycloudflare.com)").option("--cache-dir <dir>", "Vite's dependency cache, so parallel dev servers do not share one").action(async (opts) => {
+	const server = await runDev({
+		port: Number(opts.port),
+		envVar: opts.env,
+		projectDir: process.cwd(),
+		cacheDir: opts.cacheDir && path.resolve(opts.cacheDir),
+		allowedHosts: parseHosts(opts.allowedHosts)
+	}, out);
+	process.once("SIGINT", () => void server.close().then(() => process.exit(0)));
+	process.once("SIGTERM", () => void server.close().then(() => process.exit(0)));
+});
+program.command("build").description("Build the deploy bundle of the project in the current directory: its config module, admin UI and manifest").option("--out <dir>", "output folder", "dist").action(async (opts) => {
+	const manifest = await buildDeployBundle({
+		projectDir: process.cwd(),
+		outDir: path.resolve(opts.out)
+	});
+	const packages = manifest.nodeModules ? `, ${manifest.nodeModules}/` : "";
+	out(`built ${opts.out}: ${manifest.server}${packages}, ${manifest.public}/ and ${manifestFile} (api ${manifest.api.join(", ")})\n`);
+});
+program.command("build-serve").description("Bundle the serve runtime into one file for Bun: bun --no-install protobase-serve.js <bundle.js>").option("--out <file>", "output file", "dist/protobase-serve.js").action(async (opts) => {
+	await buildServeRuntime({ outFile: path.resolve(opts.out) });
+	out(`built ${opts.out}\n`);
+});
+program.command("serve").description("Serve a bundle written by `protobase build` until SIGTERM or SIGINT: a folder as a host serves it, a config module as its API alone").argument("<bundle>", "the bundle folder, e.g. dist, or its dist/protobase.config.js").action(async (bundle) => {
+	loadNearestEnvFile(process.cwd());
+	if (statSync(bundle).isDirectory()) await serveBundleDir(bundle, process.env, out);
+	else await serveBundle(bundle, process.env, out);
+});
+registerUsers(program);
+registerToken(program);
+const run = (argv) => program.parseAsync(argv).catch((error) => {
+	process.stderr.write(`error: ${error.message}\n`);
+	process.exitCode = 1;
+});
+//#endregion
+export { run };

package/dist/module-file.js

@@ -0,0 +1,6 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/module-file.ts
+const moduleFile = (relative, from) => fileURLToPath(new URL(`${relative}${path.extname(from)}`, from));
+//#endregion
+export { moduleFile };

package/dist/package.js

@@ -0,0 +1,4 @@
+//#region package.json
+var version = "0.1.1";
+//#endregion
+export { version };

package/dist/project/admin-app.js

@@ -0,0 +1,9 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+//#region src/project/admin-app.ts
+const uiEntry = createRequire(import.meta.url).resolve("@protobase/ui");
+const uiPackageDir = path.resolve(path.dirname(uiEntry), "..");
+const adminAppDir = path.join(path.dirname(uiEntry), "app");
+const adminAppMain = `main${path.extname(uiEntry) === ".ts" ? ".tsx" : ".js"}`;
+//#endregion
+export { adminAppDir, adminAppMain, uiPackageDir };

package/dist/project/convention.js

@@ -0,0 +1,8 @@
+//#region src/project/convention.ts
+const conventionConfig = (index, uiModules) => {
+	const config = { ...index };
+	for (const [dir, exports] of uiModules) for (const [key, value] of Object.entries(exports)) if (!Object.values(config).includes(value)) config[`${dir}:${key}`] = value;
+	return config;
+};
+//#endregion
+export { conventionConfig };

package/dist/project/import-project-file.js

@@ -0,0 +1,6 @@
+import { pathToFileURL } from "node:url";
+import { tsImport } from "tsx/esm/api";
+//#region src/project/import-project-file.ts
+const importProjectFile = (file) => tsImport(pathToFileURL(file).href, import.meta.url);
+//#endregion
+export { importProjectFile };

package/dist/project/pg-db.js

@@ -0,0 +1,11 @@
+import { Kysely, PostgresDialect } from "kysely";
+//#region src/project/pg-db.ts
+const createPgDb = (pg, url, max = 10) => {
+	return new Kysely({ dialect: new PostgresDialect({ pool: new pg.Pool({
+		connectionString: url,
+		max,
+		types: { getTypeParser: (oid, format) => oid === 1082 || oid === 1114 ? (value) => value : pg.types.getTypeParser(oid, format) }
+	}) }) });
+};
+//#endregion
+export { createPgDb };

package/dist/project/project-ui.js

@@ -0,0 +1,17 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+//#region src/project/project-ui.ts
+const projectUiId = "virtual:protobase-project-ui";
+const empty = `\0${projectUiId}`;
+const projectUiFile = (projectDir) => path.join(projectDir, "protobase.ui.tsx");
+const projectUiPlugin = (projectDir) => ({
+	name: "protobase-project-ui",
+	resolveId: (id) => {
+		if (id !== "virtual:protobase-project-ui") return void 0;
+		const file = projectDir === void 0 ? void 0 : projectUiFile(projectDir);
+		return file && existsSync(file) ? file : empty;
+	},
+	load: (id) => id === empty ? "export default {}\n" : void 0
+});
+//#endregion
+export { projectUiFile, projectUiId, projectUiPlugin };

package/dist/scaffold/data-file.js

@@ -0,0 +1,44 @@
+import { tableKey } from "../db/model.js";
+import { parseSource } from "./project.js";
+import { fieldsObject, resourceChain } from "./existing-config.js";
+import { renderField } from "../infer/render-field.js";
+//#region src/scaffold/data-file.ts
+const propertyText = ({ proposal, ignored }) => ignored ? `${proposal.name}: null` : `${proposal.name}: ${renderField(proposal)}`;
+const refs = (names) => names.length === 1 ? `r.${names[0]}` : `[${names.map((n) => `r.${n}`).join(", ")}]`;
+const docComment = (plan) => {
+	const unique = plan.unique.map((columns) => `(${columns.join(", ")})`).join(", ");
+	return `/** ${tableKey(plan.table)}${unique ? `. Unique: ${unique}` : ""} */\n`;
+};
+const renderDataFile = (plan) => {
+	const properties = plan.decisions.map((d) => `    ${propertyText(d)},`).join("\n");
+	const tail = [
+		`  .primaryKey((r) => ${refs(plan.primaryKey)})`,
+		plan.softDelete && `  .softDelete((r) => r.${plan.softDelete})`,
+		plan.tenant && `  .tenant((r) => r.${plan.tenant})`
+	].filter(Boolean);
+	return [
+		`import { f, resource } from '@protobase/schema'`,
+		"",
+		`${docComment(plan)}export const ${plan.name} = resource('${plan.name}')`,
+		`  .table('${tableKey(plan.table)}')`,
+		`  .fields({`,
+		properties,
+		`  })`,
+		...tail,
+		""
+	].join("\n");
+};
+const addFieldsToDataFile = (text, decisions) => {
+	if (decisions.length === 0) return text;
+	const source = parseSource(text);
+	const chain = resourceChain(source);
+	const object = chain && fieldsObject(chain.chainTop);
+	if (!object) throw new Error("data.ts has no resource(...).fields({...}) object to extend");
+	for (const decision of decisions) object.addPropertyAssignment({
+		name: decision.proposal.name,
+		initializer: decision.ignored ? "null" : renderField(decision.proposal)
+	});
+	return source.getFullText();
+};
+//#endregion
+export { addFieldsToDataFile, renderDataFile };

package/dist/scaffold/drift.js

@@ -0,0 +1,30 @@
+import { typesCompatible } from "../infer/compat.js";
+import { proposeField } from "../infer/proposal.js";
+import { renderField } from "../infer/render-field.js";
+//#region src/scaffold/drift.ts
+const sameValues = (a = [], b = []) => a.length === b.length && a.every((v) => b.includes(v));
+const detectDrift = (existing, table, context) => existing.fields.filter((field) => !field.ignored).flatMap((field) => {
+	const column = table.columns.find((c) => c.name === field.column);
+	if (!column) return [{
+		resource: existing.name,
+		field: field.name,
+		problem: `column "${field.column}" no longer exists`,
+		suggestion: `remove "${field.name}" or point .column() at its new name`
+	}];
+	if (!field.type) return [];
+	const proposal = proposeField(table, column, context);
+	const typeDrift = !typesCompatible(field.type, proposal.base);
+	const enumDrift = field.type === "enum" && proposal.base === "enum" && !sameValues(field.enumValues, proposal.enumValues);
+	if (!typeDrift && !enumDrift) return [];
+	return [{
+		resource: existing.name,
+		field: field.name,
+		problem: typeDrift ? `declared ${field.type}, database is ${column.formatted}` : `enum values differ from the database (${proposal.enumValues?.join(", ")})`,
+		suggestion: `${field.name}: ${renderField({
+			...proposal,
+			name: field.name
+		})}`
+	}];
+});
+//#endregion
+export { detectDrift };