@protobase/server 0.68.2 → 0.68.4

package/dist/package.js

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

package/dist/user-tables/check-definition.js

@@ -4,7 +4,7 @@ const reservedFields = ["id", "etag"];
 const isFieldType = (type) => definitionFieldTypes.includes(type);
 const fieldProblem = (field, columns, organization) => {
 	if (!isUserTableName(field.name)) return `the field name ${JSON.stringify(field.name)} is not lowercase letters, digits and "_", starting with a letter, at most 63 bytes`;
-	if (reservedFields.includes(field.name) || organization && field.name === "organization_id") return `the field name "${field.name}" is reserved`;
+	if (reservedFields.includes(field.name) || organization && field.name === organizationColumn) return `the field name "${field.name}" is reserved`;
 	if (!isFieldType(field.type)) return `the field "${field.name}" has the type ${JSON.stringify(field.type)}, which is not one of ${definitionFieldTypes.join(", ")}`;
 	if (field.type === "decimal" && (field.precision === null || field.scale === null)) return `the decimal field "${field.name}" has no precision and scale`;
 	const column = columns.get(field.name);

package/dist/user-tables/definitions-resources.js

@@ -1,5 +1,6 @@
-import { definitionFieldTypes, definitionsSchema, nameProblem, organizationColumn } from "./names.js";
+import { definitionFieldTypes, definitionsSchema, maxOrganizationNameBytes, nameProblem, organizationColumn } from "./names.js";
 import { organizationAdmins } from "./organization-access.js";
+import { maxLabelLength } from "@protobase/schema/internal";
 import { f, resource } from "@protobase/schema";
 //#region src/user-tables/definitions-resources.ts
 /** The names of the resources over the definitions: a table users add takes neither. */
@@ -36,14 +37,14 @@ const issue = (field, problem) => problem ? [{
 const definitionsResources = ({ roles, taken, organizations = false }) => {
 	const organization = organizations ? { [organizationColumn]: f.text() } : {};
 	const nameIssue = (name) => {
-		if (organizations) return nameProblem(name, "table", 42);
+		if (organizations) return nameProblem(name, "table", maxOrganizationNameBytes);
 		return nameProblem(name, "table") ?? (taken.includes(name) || ["user_tables", "user_table_fields"].includes(name) ? `"${name}" is the name of a resource of the app` : void 0);
 	};
 	const tables = resource(tablesResourceName).table(`${definitionsSchema}.tables`).fields({
 		id: f.bigint().readOnly().dbDefault().filterable().sortable(),
-		name: f.text().access(createOnly).filterable().sortable(),
-		singular_label: f.text().max(200),
-		plural_label: f.text().max(200),
+		name: f.text().access(createOnly),
+		singular_label: f.text().max(maxLabelLength),
+		plural_label: f.text().max(maxLabelLength),
 		title_field: f.text().optional(),
 		version: f.bigint().readOnly().dbDefault(),
 		table_name: f.text().readOnly().dbDefault(),
@@ -52,7 +53,7 @@ const definitionsResources = ({ roles, taken, organizations = false }) => {
 	const fields = resource(fieldsResourceName).table(`${definitionsSchema}.fields`).fields({
 		table_id: f.relation(tablesResourceName).access(createOnly).filterable(),
 		name: f.text().access(createOnly),
-		label: f.text().max(200),
+		label: f.text().max(maxLabelLength),
 		type: f.enum(definitionFieldTypes).access(createOnly),
 		required: f.boolean().default(false).access(createOnly),
 		position: f.integer().sortable(),

package/dist/user-tables/definitions-views.js

@@ -14,7 +14,8 @@ const fieldTypeLabels = {
 };
 /**
 * The tables list of the admin app, for whoever may make tables: a table's page has its fields, a link to add one and a
-* link to the table's own list, which shows once the app serves it. The title field is set once its field exists.
+* link to the table's own list, which shows once the app serves it. The title field is set once its field exists. Its
+* Import makes a new table from a file, with its fields and records.
 */
 const tablesView = view(tablesResourceName).names({
 	singular: "Table",
@@ -22,14 +23,14 @@ const tablesView = view(tablesResourceName).names({
 }).title((r) => r.plural_label).help("The tables people add to the app. Open one to give it fields or to go to its records.").nav({
 	creatorsOnly: true,
 	order: 0
-}).fields((r) => ({
+}).import("table").fields((r) => ({
 	name: r.name.label("Name").format("code").help("Its address and the name of its database table: lowercase letters, digits and _, starting with a letter. It cannot change later."),
 	plural_label: r.plural_label.label("Plural label").help("Its name in the sidebar and above its list, such as Notes."),
 	singular_label: r.singular_label.label("Singular label").help("What one record is called, such as Note."),
 	title_field: r.title_field.label("Title field").notOnCreate().help("The name of the text field that titles each record and that search looks in.")
 })).list((r) => ({
 	columns: [r.plural_label, r.name],
-	sort: [[r.name, "asc"]]
+	sort: [[r.id, "asc"]]
 })).layout((r) => [l.section("Table", [
 	r.plural_label,
 	r.singular_label,

package/dist/user-tables/names.d.ts

@@ -1,3 +1,4 @@
+import "@protobase/schema/internal";
 //#region src/user-tables/names.d.ts
 /** The schema the definitions of the tables users add live in: `tables`, and `fields` of each. */
 export declare const definitionsSchema = "table_definitions";

package/dist/user-tables/names.js

@@ -1,11 +1,10 @@
-import { reservedWords } from "./reserved-words.js";
+import { isUserTableName, maxNameBytes, maxNameBytes as maxNameBytes$1, maxOrganizationNameBytes, organizationColumn, userTableName } from "@protobase/schema/internal";
+import { userTableNameIssue } from "@protobase/schema";
 //#region src/user-tables/names.ts
 /** The schema the definitions of the tables users add live in: `tables`, and `fields` of each. */
 const definitionsSchema = "table_definitions";
 /** The schema the tables users add live in, apart from their definitions, so no name of one reaches a definitions table. */
 const userTablesSchema = "user_tables";
-/** What a name of a user table or field must be: it reaches SQL as an identifier, always quoted too. */
-const userTableName = /^[a-z][a-z0-9_]*$/;
 /** The field types a definition may give, each with the Postgres types its column may have. */
 const definitionColumnTypes = {
 	text: ["text"],
@@ -18,20 +17,12 @@ const definitionColumnTypes = {
 	json: ["jsonb"]
 };
 const definitionFieldTypes = Object.keys(definitionColumnTypes);
-const isUserTableName = (name) => userTableName.test(name) && new TextEncoder().encode(name).length <= 63;
-/** The column that holds the organization of each record of a table users add with organizations, and of each definition. */
-const organizationColumn = "organization_id";
-/** The names a field never takes: the key's, the API's for the record version, and the organization's. */
-const reservedFieldNames = [
-	"id",
-	"etag",
-	organizationColumn
-];
 /** What is wrong with a name a table or field users add is given, or `undefined` when it may have it; `maxBytes` defaults to 63. */
-const nameProblem = (name, kind, maxBytes = 63) => {
-	if (typeof name !== "string" || !isUserTableName(name) || new TextEncoder().encode(name).length > maxBytes) return `Use lowercase letters, digits and "_", starting with a letter, at most ${maxBytes} bytes`;
-	if (reservedWords.has(name)) return `"${name}" is a word SQL reserves`;
-	if (kind === "field" && reservedFieldNames.includes(name)) return `"${name}" is the name of a field every table has`;
+const nameProblem = (name, kind, maxBytes = maxNameBytes) => {
+	const issue = userTableNameIssue(name, kind, maxBytes);
+	if (issue === "form") return `Use lowercase letters, digits and "_", starting with a letter, at most ${maxBytes} bytes`;
+	if (issue === "reserved_word") return `"${name}" is a word SQL reserves`;
+	if (issue === "reserved_field") return `"${name}" is the name of a field every table has`;
 };
 //#endregion
-export { definitionColumnTypes, definitionFieldTypes, definitionsSchema, isUserTableName, nameProblem, organizationColumn, reservedFieldNames, userTableName, userTablesSchema };
+export { definitionColumnTypes, definitionFieldTypes, definitionsSchema, isUserTableName, maxNameBytes$1 as maxNameBytes, maxOrganizationNameBytes, nameProblem, organizationColumn, userTableName, userTablesSchema };

package/dist/user-tables/schema-sql.js

@@ -1,6 +1,6 @@
-import { definitionFieldTypes, definitionsSchema, userTableName, userTablesSchema } from "./names.js";
+import { definitionFieldTypes, definitionsSchema, maxNameBytes, userTableName, userTablesSchema } from "./names.js";
 //#region src/user-tables/schema-sql.ts
-const nameCheck = (column) => `check (${column} ~ '${userTableName.source}' and octet_length(${column}) <= 63)`;
+const nameCheck = (column) => `check (${column} ~ '${userTableName.source}' and octet_length(${column}) <= ${maxNameBytes})`;
 /**
 * The table of definitions: one row per table users add, its labels and a version, 1 when added, that each change of it
 * raises. With organizations a definition belongs to the one it was made in (`organization_id`), and its table is named

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@protobase/server",
-  "version": "0.68.2",
+  "version": "0.68.4",
   "description": "The Protobase REST API as a Hono app, with Better Auth sign-in.",
   "license": "Apache-2.0",
   "repository": {
@@ -44,11 +44,11 @@
     "@better-auth/sso": "^1.7.12",
     "@livekit/protocol": "1.53.1",
     "@modelcontextprotocol/server": "^2.3.1",
-    "@protobase/layout": "0.68.2",
-    "@protobase/query": "0.68.2",
-    "@protobase/schema": "0.68.2",
-    "@protobase/workflow-plugins": "0.68.2",
-    "@protobase/workflows": "0.68.2",
+    "@protobase/layout": "0.68.4",
+    "@protobase/query": "0.68.4",
+    "@protobase/schema": "0.68.4",
+    "@protobase/workflow-plugins": "0.68.4",
+    "@protobase/workflows": "0.68.4",
     "@react-email/render": "^2.1.0",
     "@react-pdf/primitives": "^4.4.0",
     "@react-pdf/renderer": "^4.9.0",

package/dist/user-tables/reserved-words.js

@@ -1,87 +0,0 @@
-//#region src/user-tables/reserved-words.ts
-/**
-* The key words Postgres 18 reserves, `select word from pg_get_keywords() where catcode = 'R'`: a table or field users
-* add never takes one, so its name works unquoted in any SQL a developer writes against it.
-*/
-const reservedWords = /* @__PURE__ */ new Set([
-	"all",
-	"analyse",
-	"analyze",
-	"and",
-	"any",
-	"array",
-	"as",
-	"asc",
-	"asymmetric",
-	"both",
-	"case",
-	"cast",
-	"check",
-	"collate",
-	"column",
-	"constraint",
-	"create",
-	"current_catalog",
-	"current_date",
-	"current_role",
-	"current_time",
-	"current_timestamp",
-	"current_user",
-	"default",
-	"deferrable",
-	"desc",
-	"distinct",
-	"do",
-	"else",
-	"end",
-	"except",
-	"false",
-	"fetch",
-	"for",
-	"foreign",
-	"from",
-	"grant",
-	"group",
-	"having",
-	"in",
-	"initially",
-	"intersect",
-	"into",
-	"lateral",
-	"leading",
-	"limit",
-	"localtime",
-	"localtimestamp",
-	"not",
-	"null",
-	"offset",
-	"on",
-	"only",
-	"or",
-	"order",
-	"placing",
-	"primary",
-	"references",
-	"returning",
-	"select",
-	"session_user",
-	"some",
-	"symmetric",
-	"system_user",
-	"table",
-	"then",
-	"to",
-	"trailing",
-	"true",
-	"union",
-	"unique",
-	"user",
-	"using",
-	"variadic",
-	"when",
-	"where",
-	"window",
-	"with"
-]);
-//#endregion
-export { reservedWords };