@protobase/cli 0.18.0 → 0.19.1

package/dist/build/deploy-bundle.js

@@ -6,6 +6,7 @@ import { copyPackages } from "./packages/copy-packages.js";
 import { buildTheme } from "./theme.js";
 import { shellForBuild, shellManifestFile } from "./shell.js";
 import { checkUi } from "./ui-check.js";
+import { checkViews } from "./view-check.js";
 import { existsSync } from "node:fs";
 import path from "node:path";
 import { cp, readFile, rm, writeFile } from "node:fs/promises";
@@ -49,6 +50,7 @@ const buildDeployBundle = async ({ projectDir, outDir, bun, extensions = [], onW
 		extensions,
 		components
 	});
+	await checkViews(projectDir);
 	await checkUi(projectDir, extensions, components);
 	const packages = native.length > 0 ? await copyPackages(native, path.join(outDir, bundleNodeModules)) : [];
 	const publicDir = path.join(outDir, bundleLayout.public);

package/dist/build/entry-code.js

@@ -1,10 +1,10 @@
 import { moduleFile } from "../module-file.js";
+import { uiDirs } from "../project/convention-files.js";
 import { functionFiles } from "../project/functions-folder.js";
-import { existsSync, readdirSync } from "node:fs";
+import { existsSync } from "node:fs";
 import path from "node:path";
 //#region src/build/entry-code.ts
 const conventionModule = moduleFile("../project/convention", import.meta.url);
-const uiDirs = (configDir) => readdirSync(configDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && existsSync(path.join(configDir, entry.name, "ui.ts"))).map((entry) => entry.name).sort();
 const bundleEntryCode = (projectDir, extensions = []) => {
 	const custom = path.join(projectDir, "protobase.config.ts");
 	const configDir = path.join(projectDir, "config");

package/dist/build/view-check.js

@@ -0,0 +1,18 @@
+import { loadDataConfig } from "../project/load-data-config.js";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { checkViewQueries } from "@protobase/server";
+//#region src/build/view-check.ts
+/**
+* Fails the build, instead of a page once it asks, when a view filters, counts, sorts or searches by a field that its
+* resource does not mark for it. It loads the config folder once in Node, config/index.ts and config/<dir>/ui.ts with
+* what they import; protobase.config.ts does not run, so the build still needs no secrets and no database.
+*/
+const checkViews = async (projectDir) => {
+	const configDir = path.join(projectDir, "config");
+	if (!existsSync(path.join(configDir, "index.ts"))) return;
+	const { models, views } = await loadDataConfig(configDir);
+	checkViewQueries(models, views);
+};
+//#endregion
+export { checkViews };

package/dist/db/read-only-db.js

@@ -0,0 +1,11 @@
+import { Kysely, PostgresDialect } from "kysely";
+import pg from "pg";
+//#region src/db/read-only-db.ts
+/** Kysely over one read-only session, for what the query package reads of the database, as the server reads it. */
+const readOnlyDb = (url) => new Kysely({ dialect: new PostgresDialect({ pool: new pg.Pool({
+	connectionString: url,
+	max: 1,
+	options: "-c default_transaction_read_only=on"
+}) }) });
+//#endregion
+export { readOnlyDb };

package/dist/doctor/check.js

@@ -1,5 +1,5 @@
 import { tableKey } from "../db/model.js";
-import { isUniqueSet, keyColumns, leadingIndex } from "../db/keys.js";
+import { isUniqueSet, keyColumns } from "../db/keys.js";
 import { checkEnumValues } from "../infer/check-values.js";
 import { typesCompatible } from "../infer/compat.js";
 import { columnDefault } from "../infer/defaults.js";
@@ -39,12 +39,6 @@ const checkField = (model, table, name) => {
 		resource: model.name,
 		message: `${name}: declared .dbDefault() but ${column.name} has no default the database computes`
 	});
-	if (field.filterable && table.kind !== "view" && !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) => {

package/dist/doctor/field-shapes.js

@@ -0,0 +1,58 @@
+import { anyOf, compare, holds, searchFor } from "./shape-filters.js";
+//#region src/doctor/field-shapes.ts
+const filterOn = (field) => field.type === "json" ? holds(field) : compare(field);
+/**
+* What the API takes of a resource from any caller, whatever the views show: a filter on each `.filterable()` field, a
+* sort by each `.sortable()` one, `search("...")` over its search fields, and the rows of a role limited to its own
+* records, which `.owner()` names.
+*/
+const fieldShapes = (model) => {
+	const fields = Object.values(model.fields);
+	const at = `GET /${model.name}`;
+	return [
+		...fields.filter((field) => field.sortable).map((field) => ({
+			resource: model.name,
+			request: `${at}?order_by=${field.name} asc`,
+			from: `"${field.name}" is sortable`,
+			query: { sort: [[field.name, "asc"]] }
+		})),
+		...fields.filter((field) => field.filterable).map((field) => ({
+			resource: model.name,
+			request: `${at}?filter=${field.name} = …`,
+			from: `"${field.name}" is filterable`,
+			query: { filter: filterOn(field) }
+		})),
+		...model.search?.length ? [{
+			resource: model.name,
+			request: `${at}?filter=search("…")`,
+			from: `the search over ${model.search.join(", ")}`,
+			query: { filter: searchFor }
+		}] : [],
+		...ownerShapes(model)
+	];
+};
+const ownerShapes = (model) => {
+	const owner = model.owner === void 0 ? void 0 : model.fields[model.owner];
+	if (!owner) return [];
+	return [{
+		resource: model.name,
+		request: `GET /${model.name} by a role with own capabilities`,
+		from: `"${owner.name}" is the owner`,
+		query: {},
+		scope: { rowFilter: compare(owner) }
+	}];
+};
+/** The names of the records a relation points at, which the app reads by their keys. */
+const lookupShapes = (model, models) => Object.values(model.fields).flatMap((field) => {
+	const target = field.relation ? models[field.relation.resource] : void 0;
+	const key = target?.primaryKey.length === 1 ? target.fields[target.primaryKey[0]] : void 0;
+	if (!target || !key) return [];
+	return [{
+		resource: target.name,
+		request: `GET /${target.name}?filter=${key.name} in (…)`,
+		from: `the names ${model.name}.${field.name} shows`,
+		query: { filter: anyOf(key) }
+	}];
+});
+//#endregion
+export { fieldShapes, lookupShapes };

package/dist/doctor/index-issues.js

@@ -0,0 +1,36 @@
+import { uncoveredColumns } from "@protobase/query";
+//#region src/doctor/index-issues.ts
+const kinds = {
+	btree: "index",
+	trigram: "pg_trgm index",
+	digits: "pg_trgm index",
+	gin: "GIN index"
+};
+const served = (column) => column.need === "digits" ? `the digits of "${column.column}"` : `the column "${column.column}"`;
+/**
+* The reads of `model` that the scan guard refuses with the table's indexes, by the scan guard's own rule: one error per
+* index to add, naming each read that needs it and where it comes from.
+*/
+const indexIssues = (model, table, shapes) => {
+	const refusals = /* @__PURE__ */ new Map();
+	for (const shape of shapes) {
+		if (shape.resource !== model.name) continue;
+		for (const column of uncoveredColumns(model, table, shape.query, shape.scope)) {
+			const refusal = refusals.get(column.suggestion) ?? {
+				column,
+				requests: /* @__PURE__ */ new Map()
+			};
+			const from = refusal.requests.get(shape.request) ?? [];
+			if (!from.includes(shape.from)) refusal.requests.set(shape.request, [...from, shape.from]);
+			refusals.set(column.suggestion, refusal);
+		}
+	}
+	return [...refusals.values()].map(({ column, requests }) => ({
+		severity: "error",
+		resource: model.name,
+		message: `no ${kinds[column.need]} serves ${served(column)}, so the API refuses:${[...requests].map(([request, from]) => `\n            ${request} (${from.join("; ")})`).join("")}`,
+		suggestion: `${column.suggestion};`
+	}));
+};
+//#endregion
+export { indexIssues };

package/dist/doctor/page-shapes.js

@@ -0,0 +1,43 @@
+import { configFilter, configSort, sortText } from "./shape-filters.js";
+import { listSort } from "./view-shapes.js";
+import { walkTree } from "@protobase/layout";
+//#region src/doctor/page-shapes.ts
+const listing = [
+	"RecordRow",
+	"Table",
+	"CardRow",
+	"RecordCard",
+	"Stat"
+];
+const text = (value) => typeof value === "string" ? value : void 0;
+const blockSort = (node, model, view) => {
+	const given = configSort(model, text(node.props.sort));
+	if (given) return given;
+	return node.type === "RecordRow" ? listSort(model, view) : void 0;
+};
+const title = (node) => text(node.props.title) ?? text(node.props.label);
+/** The reads of a composed page: each block that lists records, with its filter and sort. */
+const pageShapes = (page, models, views) => {
+	const shapes = [];
+	walkTree(page.tree, (node) => {
+		const model = node.custom ? void 0 : models[text(node.props.resource) ?? ""];
+		if (!model || !listing.includes(node.type) || node.type === "RecordCard" && node.props.recordKey !== void 0) return;
+		const source = text(node.props.filter);
+		const filter = configFilter(model, source);
+		const sort = node.type === "Stat" ? void 0 : blockSort(node, model, views.find((view) => view.resource === model.name && !view.roles));
+		const params = [...source?.trim() ? [`filter=${source}`] : [], ...sort ? [`order_by=${sortText(sort)}`] : []];
+		const named = title(node);
+		shapes.push({
+			resource: model.name,
+			request: `GET /${model.name}${params.length > 0 ? `?${params.join("&")}` : ""}`,
+			from: `page "${page.name}", <${node.type}${named ? ` "${named}"` : ""}>`,
+			query: {
+				...filter && { filter },
+				...sort && { sort }
+			}
+		});
+	});
+	return shapes;
+};
+//#endregion
+export { pageShapes };

package/dist/doctor/read-shapes.js

@@ -0,0 +1,18 @@
+import { fieldShapes, lookupShapes } from "./field-shapes.js";
+import { viewShapes } from "./view-shapes.js";
+import { pageShapes } from "./page-shapes.js";
+//#region src/doctor/read-shapes.ts
+/**
+* Every read the API takes of the resources and the app makes of them, which the scan guard judges when it runs: what
+* the fields allow, the relations' lookups, each view's pages and each composed page's blocks.
+*/
+const readShapes = ({ models, views, pages }) => {
+	const byName = Object.fromEntries(models.map((model) => [model.name, model]));
+	return [
+		...models.flatMap((model) => [...fieldShapes(model), ...lookupShapes(model, byName)]),
+		...views.flatMap((view) => viewShapes(view, byName)),
+		...pages.flatMap((page) => pageShapes(page, byName, views))
+	];
+};
+//#endregion
+export { readShapes };

package/dist/doctor/run.js

@@ -1,15 +1,23 @@
+import { loadDataConfig } from "../project/load-data-config.js";
 import { connect } from "../db/connect.js";
 import { introspect } from "../db/introspect.js";
+import { readOnlyDb } from "../db/read-only-db.js";
 import { checkResource } from "./check.js";
-import { loadResourceModels } from "./load-config.js";
+import { indexIssues } from "./index-issues.js";
+import { readShapes } from "./read-shapes.js";
+import { tableIndexes } from "@protobase/query";
 //#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);
+	const config = await loadDataConfig(options.configDir);
+	const { models } = config;
 	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, { views: true }).finally(() => sql.end());
-	const issues = models.flatMap((model) => checkResource(model, tables));
+	const db = readOnlyDb(options.url);
+	const shapes = readShapes(config);
+	const indexes = await Promise.all(models.map(async (model) => indexIssues(model, await tableIndexes(db, model), shapes))).finally(() => db.destroy());
+	const issues = models.flatMap((model, i) => [...checkResource(model, tables), ...indexes[i]]);
 	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`);

package/dist/doctor/shape-filters.js

@@ -0,0 +1,96 @@
+import { checkFilter, checkOrderBy, parseFilter, parseOrderBy } from "@protobase/schema";
+//#region src/doctor/shape-filters.ts
+const span = {
+	start: 0,
+	end: 0
+};
+const number = {
+	kind: "number",
+	value: 0,
+	raw: "0",
+	span
+};
+const compare = (field, op = "=") => ({
+	kind: "compare",
+	op,
+	field,
+	value: number,
+	span
+});
+const isTrue = (field) => ({
+	kind: "compare",
+	op: "=",
+	field,
+	value: {
+		kind: "boolean",
+		value: true,
+		span
+	},
+	span
+});
+const anyOf = (field) => ({
+	kind: "in",
+	field,
+	values: [number],
+	span
+});
+/** A JSON field is filtered by a key's value (`tags:urgent`), a GIN index's read. */
+const holds = (field) => ({
+	kind: "has",
+	field,
+	value: {
+		kind: "string",
+		value: "",
+		span
+	},
+	span
+});
+const searchFor = {
+	kind: "search",
+	text: "…",
+	span
+};
+const all = (filters) => {
+	const present = filters.filter((filter) => filter !== void 0);
+	return present.length < 2 ? present[0] : {
+		kind: "and",
+		args: present,
+		span
+	};
+};
+const any = (filters) => filters.length === 1 ? filters[0] : {
+	kind: "or",
+	args: filters,
+	span
+};
+const trusted = (model) => ({
+	...model,
+	fields: Object.fromEntries(Object.entries(model.fields).map(([name, field]) => [name, {
+		...field,
+		filterable: true,
+		sortable: true
+	}]))
+});
+/** A filter the config writes, such as a related section's, resolved against the resource; undefined when empty. */
+const configFilter = (model, source) => {
+	if (!source?.trim()) return void 0;
+	const parsed = parseFilter(source);
+	if (!parsed.ok) throw new Error(`The filter "${source}" of ${model.name} does not parse: ${parsed.errors[0].message}`);
+	if (!parsed.ast) return void 0;
+	const checked = checkFilter(trusted(model), parsed.ast);
+	if (!checked.ok) throw new Error(`The filter "${source}" does not fit ${model.name}: ${checked.errors[0].message}`);
+	return checked.filter;
+};
+/** A sort the config writes, such as `published_at desc`, resolved against the resource; undefined when empty. */
+const configSort = (model, source) => {
+	if (!source?.trim()) return void 0;
+	const parsed = parseOrderBy(source);
+	if (!parsed.ok) throw new Error(`The sort "${source}" of ${model.name} does not parse: ${parsed.errors[0].message}`);
+	const checked = checkOrderBy(trusted(model), parsed.items);
+	if (!checked.ok) throw new Error(`The sort "${source}" does not fit ${model.name}: ${checked.errors[0].message}`);
+	return checked.sort;
+};
+/** A sort as `order_by` writes it: `name asc, id desc`. */
+const sortText = (sort) => sort.map(([field, direction]) => `${field} ${direction}`).join(", ");
+//#endregion
+export { all, any, anyOf, compare, configFilter, configSort, holds, isTrue, searchFor, sortText };

package/dist/doctor/view-shapes.js

@@ -0,0 +1,167 @@
+import { all, any, anyOf, compare, configFilter, configSort, isTrue, sortText } from "./shape-filters.js";
+//#region src/doctor/view-shapes.ts
+const numberTypes = [
+	"integer",
+	"bigint",
+	"decimal"
+];
+const request = (resource, filter, sort) => {
+	const params = [...filter ? [`filter=${filter}`] : [], ...sort ? [`order_by=${sortText(sort)}`] : []];
+	return `GET /${resource}${params.length > 0 ? `?${params.join("&")}` : ""}`;
+};
+/** The order a list opens in, as the app asks for it: the view's sort, or the primary key's. */
+const listSort = (model, view) => {
+	return [view?.list?.sort?.[0] ?? [model.primaryKey[0], "asc"]];
+};
+const widgetShapes = (model, widget, from) => {
+	const shape = (request, query) => ({
+		resource: model.name,
+		request,
+		from,
+		query
+	});
+	const field = (name) => model.fields[name];
+	if (widget.kind === "flags") {
+		const fields = widget.fields.flatMap((name) => field(name) ? [field(name)] : []);
+		if (fields.length === 0) return [];
+		return [...fields.map((flag) => shape(`GET /${model.name}:facets?field=${flag.name}`, { groupBy: flag.name })), shape(request(model.name, fields.map((flag) => `${flag.name} = true`).join(" OR "), void 0), { filter: any(fields.map(isTrue)) })];
+	}
+	const target = field(widget.field);
+	if (!target) return [];
+	if (widget.kind === "toggle") return [shape(request(model.name, `${target.name} = true`, void 0), { filter: isTrue(target) })];
+	if (widget.kind === "dateRange") return [shape(request(model.name, `${target.name} >= …`, void 0), { filter: compare(target, ">=") })];
+	if (widget.kind === "range" || numberTypes.includes(target.type)) return [shape(request(model.name, `${target.name} >= … AND ${target.name} <= …`, void 0), { filter: all([compare(target, ">="), compare(target, "<=")]) })];
+	return [shape(`GET /${model.name}:facets?field=${target.name}`, { groupBy: target.name }), shape(request(model.name, `${target.name} in (…)`, void 0), { filter: anyOf(target) })];
+};
+const relatedShapes = (item, owner, models) => {
+	const target = models[item.resource];
+	const match = target?.fields[item.field];
+	if (!target || !match) return [];
+	const from = `related "${item.title}" on the ${owner} record page`;
+	const filter = configFilter(target, item.filter);
+	const sort = configSort(target, item.sort);
+	const extra = item.filter ? ` AND (${item.filter})` : "";
+	const via = item.through && models[item.through.resource];
+	const viaField = via && via.fields[item.through.field];
+	const join = via && viaField ? [{
+		resource: via.name,
+		request: request(via.name, `${viaField.name} = …${item.through.filter ? ` AND (${item.through.filter})` : ""}`, void 0),
+		from,
+		query: { filter: all([compare(viaField), configFilter(via, item.through.filter)]) }
+	}] : [];
+	const matched = item.through ? anyOf(match) : compare(match);
+	const text = item.through ? `${match.name} in (…)` : `${match.name} = …`;
+	return [...join, {
+		resource: target.name,
+		request: request(target.name, `${text}${extra}`, sort),
+		from,
+		query: {
+			filter: all([matched, filter]),
+			...sort && { sort }
+		}
+	}];
+};
+const galleryShapes = (item, owner, models) => {
+	const holder = item.photos && models[item.photos.resource];
+	const field = holder?.fields[item.photos.field];
+	if (!holder || !field) return [];
+	const sort = configSort(holder, item.photos.sort);
+	return [{
+		resource: holder.name,
+		request: request(holder.name, `${field.name} = …`, sort),
+		from: `gallery "${item.title}" on the ${owner} record page`,
+		query: {
+			filter: compare(field),
+			...sort && { sort }
+		}
+	}];
+};
+const displayShapes = (model, view, models) => (view.list?.displays ?? []).flatMap((display) => {
+	if (display.kind === "map") {
+		const latitude = model.fields[display.latitude];
+		const longitude = model.fields[display.longitude];
+		if (!latitude || !longitude) return [];
+		const filter = all([
+			compare(latitude, ">="),
+			compare(latitude, "<="),
+			compare(longitude, ">="),
+			compare(longitude, "<=")
+		]);
+		return [{
+			resource: model.name,
+			request: `GET /${model.name}:map?filter=${latitude.name} >= … AND ${latitude.name} <= … AND ${longitude.name} >= … AND ${longitude.name} <= …`,
+			from: `the map display "${display.name}"`,
+			query: { filter }
+		}];
+	}
+	const photos = display.kind === "cards" ? display.photos : void 0;
+	const holder = photos && models[photos.resource];
+	const field = holder?.fields[photos.field];
+	if (!holder || !field) return [];
+	const sort = configSort(holder, photos.sort);
+	return [{
+		resource: holder.name,
+		request: request(holder.name, `${field.name} in (…)`, sort),
+		from: `the photos of the ${model.name} cards`,
+		query: {
+			filter: anyOf(field),
+			...sort && { sort }
+		}
+	}];
+});
+const searchesShapes = (view, models) => {
+	const unseen = view.searchesOf?.unseen;
+	const target = view.searchesOf && models[view.searchesOf.resource];
+	const field = unseen && target?.fields[unseen.field];
+	if (!target || !field) return [];
+	const sort = [[field.name, "desc"]];
+	return [{
+		resource: target.name,
+		request: request(target.name, `${field.name} > …`, sort),
+		from: `the new records of each saved search of ${view.resource}`,
+		query: {
+			filter: compare(field, ">"),
+			sort
+		}
+	}];
+};
+const recentShapes = (model, view) => {
+	const recent = view.nav?.recent;
+	if (!recent) return [];
+	const filter = configFilter(model, recent.filter);
+	const sort = configSort(model, recent.orderBy) ?? listSort(model, view);
+	return [{
+		resource: model.name,
+		request: request(model.name, recent.filter, sort),
+		from: "the recent records in the sidebar",
+		query: {
+			...filter && { filter },
+			sort
+		}
+	}];
+};
+/**
+* The reads a view's pages make: its list in its order, the filter widgets and their counts, its displays' maps and
+* photos, the records of its related sections and the photos of its galleries, the recent records in the sidebar and a saved search's new records.
+*/
+const viewShapes = (view, models) => {
+	const model = models[view.resource];
+	if (!model) return [];
+	const sort = listSort(model, view);
+	const list = view.roles ? `the ${model.name} list for ${view.roles.join(", ")}` : `the ${model.name} list`;
+	return [
+		{
+			resource: model.name,
+			request: request(model.name, void 0, sort),
+			from: `${list}'s order`,
+			query: { sort }
+		},
+		...view.filters.flatMap((widget) => widgetShapes(model, widget, `${list}'s ${widget.kind === "dateRange" ? "date range" : widget.kind} filter`)),
+		...displayShapes(model, view, models),
+		...view.layout.flatMap((item) => item.kind === "related" ? relatedShapes(item, model.name, models) : item.kind === "gallery" ? galleryShapes(item, model.name, models) : []),
+		...recentShapes(model, view),
+		...searchesShapes(view, models)
+	];
+};
+//#endregion
+export { listSort, viewShapes };

package/dist/package.js

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

package/dist/project/convention-files.js

@@ -0,0 +1,7 @@
+import { existsSync, readdirSync } from "node:fs";
+import path from "node:path";
+//#region src/project/convention-files.ts
+/** The folders of a config folder that hold a ui.ts, whose views the convention adds to config/index.ts's, in name order. */
+const uiDirs = (configDir) => readdirSync(configDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && existsSync(path.join(configDir, entry.name, "ui.ts"))).map((entry) => entry.name).sort();
+//#endregion
+export { uiDirs };

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

@@ -1,11 +1,21 @@
 import { runnerImport } from "vite";
 //#region src/project/import-project-file.ts
-const importProjectFile = async (file) => {
+const importProjectFile = async (file, plugins = []) => {
 	const { module } = await runnerImport(file, {
 		configFile: false,
-		logLevel: "error"
+		logLevel: "error",
+		plugins
 	});
 	return module;
 };
+/**
+* Imports `code` as if it were the project's file `file`, which need not exist: its imports resolve from there, and
+* the modules it imports are loaded once, however many of them import each other.
+*/
+const importProjectCode = (file, code) => importProjectFile(file, [{
+	name: "protobase-project-code",
+	resolveId: (id) => id === file ? `\0${file}` : void 0,
+	load: (id) => id === `\0${file}` ? code : void 0
+}]);
 //#endregion
-export { importProjectFile };
+export { importProjectCode, importProjectFile };

package/dist/project/load-data-config.js

@@ -0,0 +1,30 @@
+import { importProjectCode } from "./import-project-file.js";
+import { uiDirs } from "./convention-files.js";
+import { conventionConfig } from "./convention.js";
+import path from "node:path";
+import { configExports } from "@protobase/server";
+//#region src/project/load-data-config.ts
+/**
+* The resources, views and pages of a config folder, as the config module has them by convention: config/index.ts and
+* every config/<dir>/ui.ts. Only those files and what they import run, not protobase.config.ts, which may need secrets.
+*/
+const loadDataConfig = async (configDir) => {
+	const dirs = uiDirs(configDir);
+	const code = [
+		`import * as index from ${JSON.stringify(path.join(configDir, "index.ts"))}`,
+		...dirs.map((dir, i) => `import * as ui${i} from ${JSON.stringify(path.join(configDir, dir, "ui.ts"))}`),
+		"export { index }",
+		`export const ui = [${dirs.map((dir, i) => `[${JSON.stringify(dir)}, ui${i}]`).join(", ")}]`,
+		""
+	].join("\n");
+	const loaded = await importProjectCode(path.join(configDir, "protobase-data-config.js"), code);
+	const config = conventionConfig(loaded.index, loaded.ui);
+	const { resources, views, pages } = configExports(config);
+	return {
+		models: resources.map((resource) => resource.toModel()),
+		views: views.map((view) => view.toModel()),
+		pages: pages.map((page) => page.toModel())
+	};
+};
+//#endregion
+export { loadDataConfig };

package/dist/serve/host-modules.js

@@ -1,9 +1,11 @@
 import * as server from "@protobase/server";
 import * as postgres$1 from "postgres";
+import * as query from "@protobase/query";
+import * as kysely from "kysely";
+import * as pg$1 from "pg";
 import * as schema from "@protobase/schema";
+import * as layout from "@protobase/layout";
 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 reactEmailRender from "@react-email/render";
 import * as apiReference from "@scalar/hono-api-reference";
@@ -17,8 +19,6 @@ import * as kyselyPostgres from "kysely/helpers/postgres";
 import * as react from "react";
 import * as reactJsxRuntime from "react/jsx-runtime";
 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,

package/dist/serve/lifecycle.js

@@ -3,8 +3,8 @@ import { createPgDb } from "../project/pg-db.js";
 import { createServeApp } from "./app.js";
 import { startCleanupTimer } from "./cleanup-timer.js";
 import { checkAuthSchema, checkChanges, checkJobsSchema, checkWebhooksSchema, configExports, createFileCleanup, startJobs } from "@protobase/server";
-import { createAdaptorServer } from "@hono/node-server";
 import pg from "pg";
+import { createAdaptorServer } from "@hono/node-server";
 //#region src/serve/lifecycle.ts
 const listen = (server, port) => new Promise((resolve, reject) => {
 	server.once("error", reject);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@protobase/cli",
-  "version": "0.18.0",
+  "version": "0.19.1",
   "description": "The protobase command: scaffold, doctor, dev, build and serve a Protobase project.",
   "license": "Apache-2.0",
   "repository": {
@@ -34,11 +34,11 @@
   "dependencies": {
     "@hono/node-server": "^2.1.3",
     "@hono/vite-dev-server": "^0.26.1",
-    "@protobase/layout": "0.18.0",
-    "@protobase/query": "0.18.0",
-    "@protobase/schema": "0.18.0",
-    "@protobase/server": "0.18.0",
-    "@protobase/ui": "0.18.0",
+    "@protobase/layout": "0.19.1",
+    "@protobase/query": "0.19.1",
+    "@protobase/schema": "0.19.1",
+    "@protobase/server": "0.19.1",
+    "@protobase/ui": "0.19.1",
     "@react-email/render": "^2.1.0",
     "@scalar/hono-api-reference": "^0.12.10",
     "@tailwindcss/vite": "^4.3.3",

package/dist/doctor/load-config.js

@@ -1,10 +0,0 @@
-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 };