@protobase/server 0.55.2 → 0.55.4

package/dist/assistant/records.js

@@ -1,7 +1,7 @@
 import { notFound } from "../problem.js";
 import { aggregate } from "../aggregate-groups.js";
-import { runWrite } from "../write-pipeline.js";
 import { decodeKeyText } from "../key.js";
+import { runWrite } from "../write-pipeline.js";
 import { runBatch } from "../batch/run-batch.js";
 import { listRecords } from "../list-service.js";
 import { readRecord } from "../read-service.js";

package/dist/error-handler.js

@@ -26,10 +26,12 @@ const queryProblem = (error) => {
 	return new HttpProblem(status, error.code.replaceAll("_", "-"), titles[status] ?? "Not Implemented", error.message);
 };
 const isDatabaseError = (error) => error instanceof Error && /^[0-9A-Z]{5}$/.test(String(error.code));
+/** The 409 of a unique violation, with the key of the record holding the values (`existing.key`) when the caller may read it. */
+const takenProblem = (key) => new HttpProblem(409, "conflict", "Conflict", "A record with the same unique value already exists", key === void 0 ? {} : { existing: { key } });
 const databaseProblem = (error) => {
 	if (error.code === "25006") return new HttpProblem(503, "read-only", "Service Unavailable", "The app is read-only while it is being updated", {}, { "Retry-After": "5" });
 	if (error.code === "57014") return new HttpProblem(504, "statement-timeout", "Gateway Timeout", "A query ran longer than its statement timeout, so the database stopped it");
-	if (error.code === "23505") return new HttpProblem(409, "conflict", "Conflict", "A record with the same unique value already exists");
+	if (error.code === "23505") return takenProblem();
 	if (error.code === "23503") return new HttpProblem(409, "conflict", "Conflict", "The record points at, or is pointed at by, another record");
 	if (error.code === "40P01") return new HttpProblem(409, "conflict", "Conflict", "The record was written at the same time as another; send it again");
 	if (error.code === "23502") return new HttpProblem(400, "invalid-record", "Bad Request", "A required column has no value");
@@ -65,4 +67,4 @@ const createErrorHandler = (onUnhandledError, statementTimeoutMs) => (error, c)
 	return problemResponse(new HttpProblem(500, "internal-error", titles[500], "The server failed to handle the request"), c.req.path);
 };
 //#endregion
-export { createErrorHandler, isDatabaseError, problemOf, queryProblem };
+export { createErrorHandler, isDatabaseError, problemOf, queryProblem, takenProblem };

package/dist/open-existing.js

@@ -0,0 +1,31 @@
+import { isDatabaseError, takenProblem } from "./error-handler.js";
+import { insertRecord, insertUnlessTaken, takenKeySetting } from "./records.js";
+import { fetchReadable } from "./fetch-readable.js";
+import { firstKeyField } from "./write-shared.js";
+import { decodeKeyText } from "./key.js";
+import { encodeKey } from "@protobase/schema/internal";
+import { sql } from "kysely";
+//#region src/open-existing.ts
+const readableTakenKey = async (trx, access) => {
+	if (!access.resolved.operations.read) return;
+	const { rows } = await sql`select current_setting(${takenKeySetting}) as key`.execute(trx);
+	const key = decodeKeyText(access.entry, encodeKey(JSON.parse(rows[0].key)));
+	return await fetchReadable(trx, access, key, "hide", { fields: [firstKeyField(access)] }) ? encodeKey(key) : void 0;
+};
+/**
+* Inserts a create's row. On a resource with `.openExisting()`, a row whose values of that unique key a record already
+* holds is refused with the 409 any unique violation answers, plus that record's key when the caller may read it. A
+* row with no values given at all is inserted plainly, as the conflict needs a column to name.
+*/
+const insertOrOpen = async (trx, access, values, shape) => {
+	const unique = access.full.openExisting;
+	if (!unique || Object.keys(values).length === 0) return insertRecord(trx, access.entry, values, shape);
+	const inserted = await insertUnlessTaken(trx, access.entry, values, unique, shape).catch((error) => {
+		if (isDatabaseError(error) && error.code === "42P10") throw new Error(`The openExisting fields of ${access.entry.name} (${unique.join(", ")}) are not the columns of a unique index of its table`);
+		throw error;
+	});
+	if (inserted) return inserted;
+	throw takenProblem(await readableTakenKey(trx, access));
+};
+//#endregion
+export { insertOrOpen };

package/dist/package.js

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

package/dist/records.js

@@ -30,12 +30,34 @@ const fetchRecord = async (db, entry, key, tenant, options = {}) => {
 	const query = sql`select ${returningList(entry, shape.fields)} from ${tableId(entry.model)} as t${whereClause(conditions)} limit 1${lockClause(lock)}`;
 	return stored(entry, (await rowsOf(db, query))[0], shape);
 };
-const insertRecord = async (db, entry, values, shape = {}) => {
+const insertBody = (entry, values) => {
 	const fields = Object.keys(values).map((name) => entry.model.fields[name]);
-	const body = fields.length === 0 ? sql`default values` : sql`(${sql.join(fields.map(columnId))}) values (${sql.join(fields.map((field) => storedValue(field, values[field.name])))})`;
-	const query = sql`insert into ${tableId(entry.model)} ${body} returning ${returningList(entry, shape.fields)}`;
+	return fields.length === 0 ? sql`default values` : sql`(${sql.join(fields.map(columnId))}) values (${sql.join(fields.map((field) => storedValue(field, values[field.name])))})`;
+};
+const insertRecord = async (db, entry, values, shape = {}) => {
+	const query = sql`insert into ${tableId(entry.model)} ${insertBody(entry, values)} returning ${returningList(entry, shape.fields)}`;
 	return await stored(entry, (await rowsOf(db, query))[0], shape);
 };
+/** The setting `insertUnlessTaken` leaves the taken row's key in, as a JSON array of text, for the rest of the transaction. */
+const takenKeySetting = "protobase.taken_key";
+/**
+* Inserts the row unless another row already holds its values of the unique key `unique` (field names), and then gives
+* `undefined` and leaves that row's key in `takenKeySetting`, its parts as text. The conflict's `do update` never
+* updates: its condition only records the key and is false, so no update trigger fires; Postgres still locks the taken
+* row until the transaction ends, and asks for the update privilege. A violation of any other unique key raises 23505
+* as a plain insert does. `values` must name at least one field, the column the never-run update would set.
+*/
+const insertUnlessTaken = async (db, entry, values, unique, shape = {}) => {
+	const { model } = entry;
+	const first = Object.keys(values)[0];
+	if (first === void 0) throw new Error(`A ${entry.name} record with no values given cannot open an existing one`);
+	const set = columnId(model.fields[first]);
+	const target = sql.join(unique.map((name) => columnId(model.fields[name])));
+	const key = sql.join(model.primaryKey.map((name) => sql`t.${columnId(model.fields[name])}::text`));
+	const taken = sql`set_config(${takenKeySetting}, json_build_array(${key})::text, true)`;
+	const query = sql`insert into ${tableId(model)} as t ${insertBody(entry, values)} on conflict (${target}) do update set ${set} = t.${set} where ${taken} is null returning ${returningList(entry, shape.fields)}`;
+	return stored(entry, (await rowsOf(db, query))[0], shape);
+};
 const etagBump = (entry) => {
 	if (!entry.etag) return [];
 	const column = columnId(entry.etag.field);
@@ -69,4 +91,4 @@ const restoreRecord = async (db, entry, key, tenant, shape = {}) => {
 	return await stored(entry, (await rowsOf(db, query))[0], shape);
 };
 //#endregion
-export { deleteRecord, fetchRecord, insertRecord, restoreRecord, updateRecord };
+export { deleteRecord, fetchRecord, insertRecord, insertUnlessTaken, restoreRecord, takenKeySetting, updateRecord };

package/dist/routes/record.js

@@ -1,8 +1,8 @@
 import { notFound } from "../problem.js";
 import { pickFields } from "../rows.js";
 import { selectedFields } from "../params.js";
-import { runWrite } from "../write-pipeline.js";
 import { keyFromPath } from "../key.js";
+import { runWrite } from "../write-pipeline.js";
 import { readRecord } from "../read-service.js";
 import { postComment } from "../comments/post-comment.js";
 import { readComments } from "../comments/read-comments.js";

package/dist/view-access.js

@@ -309,6 +309,7 @@ const viewShape = (resource, model, models, prompted, createPages, writeOnly) =>
 		group: shapes.data,
 		order: shapes.data,
 		tenant: shapes.data,
+		create: shapes.data,
 		recent: shapes.map((recent) => navRecentErrors(recent, model).length === 0 ? recent : void 0)
 	});
 	const chart = shapes.map((chart) => chartFields(chart).every((name) => Object.hasOwn(model.fields, name)) ? chart : void 0);

package/dist/write-pipeline.js

@@ -6,9 +6,10 @@ import { actorSettings, wakeDispatch } from "./changes/actor.js";
 import { isDatabaseError } from "./error-handler.js";
 import { attachFiles, scheduleRemovedFiles } from "./files/attach.js";
 import { bindingOf, pendingBinding } from "./encryption/binding.js";
-import { deleteRecord, fetchRecord, insertRecord, restoreRecord, updateRecord } from "./records.js";
+import { deleteRecord, fetchRecord, restoreRecord, updateRecord } from "./records.js";
 import { assertWritten, checkParents, checkPrecondition, decide, denied, firstKeyField, keyOf, missing, notifier, shown } from "./write-shared.js";
 import { blockedDelete } from "./blocked-delete.js";
+import { insertOrOpen } from "./open-existing.js";
 import { encryptedValuesOf, hasEncryptedValues, sealValues } from "./encryption/seal-values.js";
 import { validateBody } from "./validate-body.js";
 import { applyUpdate, planUpdate } from "./write-update.js";
@@ -45,7 +46,7 @@ const create = async (trx, deps, access, body, removed) => {
 	const parents = checkParents(trx, access, "create");
 	await parents(row);
 	const shape = { etagFields: Object.keys(access.model.fields) };
-	const inserted = await insertRecord(trx, entry, sealValues(deps.encryption, full, row, (field) => pendingBinding(full, field)), shape);
+	const inserted = await insertOrOpen(trx, access, sealValues(deps.encryption, full, row, (field) => pendingBinding(full, field)), shape);
 	const created = await bindEncrypted(trx, deps, access, row, inserted, shape);
 	await assertWritten(trx, access, created, "create", access.resolved.rowFilter.create, filter);
 	await parents(created.record);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@protobase/server",
-  "version": "0.55.2",
+  "version": "0.55.4",
   "description": "The Protobase REST API as a Hono app, with Better Auth sign-in.",
   "license": "Apache-2.0",
   "repository": {
@@ -40,9 +40,9 @@
     "@better-auth/passkey": "^1.7.12",
     "@better-auth/sso": "^1.7.12",
     "@modelcontextprotocol/server": "^2.3.1",
-    "@protobase/layout": "0.55.2",
-    "@protobase/query": "0.55.2",
-    "@protobase/schema": "0.55.2",
+    "@protobase/layout": "0.55.4",
+    "@protobase/query": "0.55.4",
+    "@protobase/schema": "0.55.4",
     "@react-email/render": "^2.1.0",
     "@scalar/hono-api-reference": "^0.12.10",
     "@sentry/core": "^11.7.0",