@rebasepro/server 0.13.0 → 0.13.1-canary.g249daa1

package/dist/{openapi-generator-BEwyiaAr.js → openapi-generator-VB0MUH8h.js}

@@ -1,8 +1,8 @@
 import { createRequire as __createRequire } from "module";
 import "process";
 __createRequire(import.meta.url);
-import { m as resolveCollectionRelations } from "./src-Cum9kox5.js";
-import "./src-_qQ3RNCK.js";
+import { h as resolveCollectionRelations } from "./src-DVb5a0bp.js";
+import "./src-Ca6NhxKs.js";
 //#region ../types/src/types/relations.ts
 /** @group Models */
 function isToMany(relation) {
@@ -13,6 +13,129 @@ function isToMany(relation) {
 function generateOpenApiSpec(collections, options = {}) {
 	const basePath = options.basePath ?? "/api";
 	const requireAuth = options.requireAuth ?? true;
+	const defaultLimit = options.listLimits?.defaultLimit ?? 50;
+	const maxLimit = options.listLimits?.maxLimit ?? 1e3;
+	/**
+	* The query parameters every list endpoint honours.
+	*
+	* Written once because it was written twice: the root listing named eight
+	* and the subcollection listing named four, though both go through the same
+	* `parseQueryOptions` and the same fetch. Four capabilities were therefore
+	* unreachable from a generated client on nested routes, and `or`/`and` were
+	* undocumented on both.
+	*/
+	const listQueryParameters = () => [
+		{
+			name: "limit",
+			in: "query",
+			schema: {
+				type: "integer",
+				default: defaultLimit,
+				maximum: maxLimit
+			},
+			description: "Maximum number of records to return"
+		},
+		{
+			name: "offset",
+			in: "query",
+			schema: {
+				type: "integer",
+				default: 0
+			},
+			description: "Number of records to skip"
+		},
+		{
+			name: "page",
+			in: "query",
+			schema: {
+				type: "integer",
+				minimum: 1
+			},
+			description: "Page number (alternative to offset). Calculates offset as (page-1)*limit"
+		},
+		{
+			name: "orderBy",
+			in: "query",
+			schema: { type: "string" },
+			description: "Sort field and direction. Accepts `field:asc` or `field:desc`, or a JSON array `[{\"field\":\"name\",\"direction\":\"asc\"}]`",
+			example: "created_at:desc"
+		},
+		{
+			name: "where",
+			in: "query",
+			schema: { type: "string" },
+			description: "JSON object filter, mapping each field to a `[operator, value]` tuple. Combines with the per-field `?field=op.value` parameters below; on the same field, the per-field parameter wins.",
+			example: "{\"status\":[\"==\",\"active\"]}"
+		},
+		{
+			name: "or",
+			in: "query",
+			schema: { type: "string" },
+			description: "Disjunction of conditions, AND-ed with `where` and `searchString`.",
+			example: "(status.eq.draft,status.eq.review)"
+		},
+		{
+			name: "and",
+			in: "query",
+			schema: { type: "string" },
+			description: "Conjunction of conditions, AND-ed with `where` and `searchString`. Ignored when `or` is also present.",
+			example: "(views.gte.10,status.eq.draft)"
+		},
+		{
+			name: "include",
+			in: "query",
+			schema: { type: "string" },
+			description: "Comma-separated list of relations to include (eager-load). Use `*` for all relations.",
+			example: "author,tags"
+		},
+		{
+			name: "fields",
+			in: "query",
+			schema: { type: "string" },
+			description: "Comma-separated list of fields to return (field selection)",
+			example: "id,name,created_at"
+		},
+		{
+			name: "searchString",
+			in: "query",
+			schema: { type: "string" },
+			description: "Text search. By default a case-insensitive substring match OR-ed across the collection's top-level string properties. A collection declaring a `search` block gets ranked full-text matching over the fields it names, and rows carry a `_score`."
+		},
+		{
+			name: "vector_search",
+			in: "query",
+			schema: { type: "string" },
+			description: "Name of the `vector` property to run a nearest-neighbour search against. Requires `vector`.",
+			example: "embedding"
+		},
+		{
+			name: "vector",
+			in: "query",
+			schema: { type: "string" },
+			description: "The query embedding, as a JSON array of numbers. Its length must match the property's declared `dimensions`.",
+			example: "[0.12,-0.04,0.98]"
+		},
+		{
+			name: "vector_distance",
+			in: "query",
+			schema: {
+				type: "string",
+				enum: [
+					"cosine",
+					"l2",
+					"inner_product"
+				],
+				default: "cosine"
+			},
+			description: "Distance function used for ordering."
+		},
+		{
+			name: "vector_threshold",
+			in: "query",
+			schema: { type: "number" },
+			description: "Drop rows farther than this distance. Rows are returned closest-first with a `_distance` field."
+		}
+	];
 	const spec = {
 		openapi: "3.0.3",
 		info: {
@@ -94,77 +217,14 @@ function generateOpenApiSpec(collections, options = {}) {
 		});
 		schemas[schemaName] = buildCollectionSchema(collection);
 		schemas[`${schemaName}Input`] = buildCollectionInputSchema(collection);
+		schemas[`${schemaName}Update`] = buildCollectionUpdateSchema(collection);
 		const dataPath = `/data/${slug}`;
 		paths[dataPath] = {
 			get: {
 				tags: [collection.name],
 				summary: `List ${collection.name}`,
 				operationId: `list${schemaName}`,
-				parameters: [
-					{
-						name: "limit",
-						in: "query",
-						schema: {
-							type: "integer",
-							default: 20,
-							maximum: 100
-						},
-						description: "Maximum number of records to return"
-					},
-					{
-						name: "offset",
-						in: "query",
-						schema: {
-							type: "integer",
-							default: 0
-						},
-						description: "Number of records to skip"
-					},
-					{
-						name: "page",
-						in: "query",
-						schema: {
-							type: "integer",
-							minimum: 1
-						},
-						description: "Page number (alternative to offset). Calculates offset as (page-1)*limit"
-					},
-					{
-						name: "orderBy",
-						in: "query",
-						schema: { type: "string" },
-						description: "Sort field and direction. Accepts `field:asc` or `field:desc`, or a JSON array `[{\"field\":\"name\",\"direction\":\"asc\"}]`",
-						example: "created_at:desc"
-					},
-					{
-						name: "where",
-						in: "query",
-						schema: { type: "string" },
-						description: "JSON object filter, mapping each field to a `[operator, value]` tuple. Combines with the per-field `?field=op.value` parameters below; on the same field, the per-field parameter wins.",
-						example: "{\"status\":[\"==\",\"active\"]}"
-					},
-					{
-						name: "include",
-						in: "query",
-						schema: { type: "string" },
-						description: "Comma-separated list of relations to include (eager-load). Use `*` for all relations.",
-						example: "author,tags"
-					},
-					{
-						name: "fields",
-						in: "query",
-						schema: { type: "string" },
-						description: "Comma-separated list of fields to return (field selection)",
-						example: "id,name,created_at"
-					},
-					{
-						name: "searchString",
-						in: "query",
-						schema: { type: "string" },
-						description: "Full-text search query"
-					},
-					...buildFilterParameters(collection)
-				],
+				parameters: [...listQueryParameters(), ...buildFilterParameters(collection)],
 				responses: {
 					200: {
 						description: "Paginated list of entities",
@@ -199,6 +259,155 @@ function generateOpenApiSpec(collections, options = {}) {
 				}
 			}
 		};
+		const idempotencyHeader = {
+			name: "Idempotency-Key",
+			in: "header",
+			required: false,
+			schema: { type: "string" },
+			description: "Names this write so a retry is recognised instead of repeated. Without it a client that lost the response cannot distinguish a replay from a second genuine batch, and the whole batch is written twice."
+		};
+		const bulkErrors = {
+			400: {
+				description: "Malformed body, an unknown field, or more rows than the per-batch limit",
+				content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } }
+			},
+			409: {
+				description: "A request with the same Idempotency-Key is still in flight",
+				content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } }
+			},
+			...errorResponses(requireAuth)
+		};
+		paths[`/data/${slug}/bulk`] = {
+			post: {
+				tags: [collection.name],
+				summary: `Create many ${collection.name} in one transaction`,
+				description: "All-or-nothing: if any row is rejected none of them land, and the error names the offending index. Every row still runs callbacks, relations and row-level security. Capped server-side because one batch holds its locks for its whole duration.",
+				operationId: `createMany${schemaName}`,
+				parameters: [idempotencyHeader],
+				requestBody: {
+					required: true,
+					content: { "application/json": { schema: {
+						type: "object",
+						required: ["rows"],
+						properties: {
+							rows: {
+								type: "array",
+								items: { $ref: `#/components/schemas/${schemaName}Input` }
+							},
+							upsert: {
+								type: "boolean",
+								description: "Write each row as INSERT ... ON CONFLICT DO UPDATE on the primary key."
+							}
+						}
+					} } }
+				},
+				responses: {
+					200: {
+						description: "The written rows, in the order given",
+						content: { "application/json": { schema: {
+							type: "object",
+							properties: {
+								data: {
+									type: "array",
+									items: { $ref: `#/components/schemas/${schemaName}` }
+								},
+								meta: {
+									type: "object",
+									properties: { written: { type: "integer" } }
+								}
+							}
+						} } }
+					},
+					...bulkErrors
+				}
+			},
+			patch: {
+				tags: [collection.name],
+				summary: `Update many ${collection.name} in one transaction`,
+				description: "Each entry names its row and the fields to change. `{ id, data }` rather than flat rows carrying their own key, because on a table keyed on something other than `id` a flat row cannot say whether a column is the address or a value to write. An id matching no row fails the batch.",
+				operationId: `updateMany${schemaName}`,
+				parameters: [idempotencyHeader],
+				requestBody: {
+					required: true,
+					content: { "application/json": { schema: {
+						type: "object",
+						required: ["updates"],
+						properties: { updates: {
+							type: "array",
+							items: {
+								type: "object",
+								required: ["id", "data"],
+								properties: {
+									id: {
+										type: "string",
+										description: "The row to update"
+									},
+									data: { $ref: `#/components/schemas/${schemaName}Update` }
+								}
+							}
+						} }
+					} } }
+				},
+				responses: {
+					200: {
+						description: "The updated rows, in the order given",
+						content: { "application/json": { schema: {
+							type: "object",
+							properties: {
+								data: {
+									type: "array",
+									items: { $ref: `#/components/schemas/${schemaName}` }
+								},
+								meta: {
+									type: "object",
+									properties: { written: { type: "integer" } }
+								}
+							}
+						} } }
+					},
+					404: {
+						description: "One of the ids matches no row; nothing was written",
+						content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } }
+					},
+					...bulkErrors
+				}
+			}
+		};
+		paths[`/data/${slug}/bulk/delete`] = { post: {
+			tags: [collection.name],
+			summary: `Delete many ${collection.name} in one transaction`,
+			description: "A POST, not `DELETE /bulk` with a body. Bodies on DELETE are permitted but widely dropped by proxies and CDNs, and several generators ignore `requestBody` on a DELETE operation — a generated client would send the request with no ids at all. Takes ids rather than a filter: a mistyped condition that empties a table cannot be reviewed at the call site the way an explicit list can. `beforeDelete`/`afterDelete` fire per row.",
+			operationId: `deleteMany${schemaName}`,
+			parameters: [idempotencyHeader],
+			requestBody: {
+				required: true,
+				content: { "application/json": { schema: {
+					type: "object",
+					required: ["ids"],
+					properties: { ids: {
+						type: "array",
+						items: { oneOf: [{ type: "string" }, { type: "integer" }] }
+					} }
+				} } }
+			},
+			responses: {
+				200: {
+					description: "How many rows were deleted",
+					content: { "application/json": { schema: {
+						type: "object",
+						properties: { meta: {
+							type: "object",
+							properties: { deleted: { type: "integer" } }
+						} }
+					} } }
+				},
+				404: {
+					description: "One of the ids matches no row; nothing was deleted",
+					content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } }
+				},
+				...bulkErrors
+			}
+		} };
 		const entityPath = `/data/${slug}/{id}`;
 		paths[entityPath] = {
 			get: {
@@ -230,32 +439,11 @@ function generateOpenApiSpec(collections, options = {}) {
 					...errorResponses(requireAuth)
 				}
 			},
+			patch: updateOperation(collection, schemaName, requireAuth),
 			put: {
-				tags: [collection.name],
-				summary: `Update ${collection.singularName || collection.name}`,
-				operationId: `update${schemaName}`,
-				parameters: [{
-					name: "id",
-					in: "path",
-					required: true,
-					schema: { type: "string" },
-					description: "Entity ID"
-				}],
-				requestBody: {
-					required: true,
-					content: { "application/json": { schema: { $ref: `#/components/schemas/${schemaName}Input` } } }
-				},
-				responses: {
-					200: {
-						description: "Updated entity",
-						content: { "application/json": { schema: { $ref: `#/components/schemas/${schemaName}` } } }
-					},
-					404: {
-						description: "Entity not found",
-						content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } }
-					},
-					...errorResponses(requireAuth)
-				}
+				...updateOperation(collection, schemaName, requireAuth),
+				operationId: `update${schemaName}ViaPut`,
+				deprecated: true
 			},
 			delete: {
 				tags: [collection.name],
@@ -292,41 +480,13 @@ function generateOpenApiSpec(collections, options = {}) {
 				tags: [collection.name],
 				summary: `List ${relationName} for ${withIndefiniteArticle(collection.singularName || collection.name)}`,
 				operationId: `list${schemaName}${toPascalCase(relationName)}`,
-				parameters: [
-					{
-						name: "parentId",
-						in: "path",
-						required: true,
-						schema: { type: "string" },
-						description: `${collection.singularName || collection.name} ID`
-					},
-					{
-						name: "limit",
-						in: "query",
-						schema: {
-							type: "integer",
-							default: 20
-						}
-					},
-					{
-						name: "offset",
-						in: "query",
-						schema: {
-							type: "integer",
-							default: 0
-						}
-					},
-					{
-						name: "orderBy",
-						in: "query",
-						schema: { type: "string" }
-					},
-					{
-						name: "searchString",
-						in: "query",
-						schema: { type: "string" }
-					}
-				],
+				parameters: [{
+					name: "parentId",
+					in: "path",
+					required: true,
+					schema: { type: "string" },
+					description: `${collection.singularName || collection.name} ID`
+				}, ...listQueryParameters()],
 				responses: {
 					200: {
 						description: `List of related ${relationName}`,
@@ -370,6 +530,58 @@ function buildCollectionSchema(collection) {
 	};
 }
 /**
+* The PATCH/PUT operation for `/data/{slug}/{id}`.
+*
+* Split out because both verbs serve it and they must not drift: the update
+* body is a **partial**, and describing it with the create schema was the bug
+* this replaces. `<Name>Input` marks every `validation.required` property as
+* required — correct for POST, wrong for an update, where omitting a field
+* means "leave it alone" rather than "I forgot it". A client generated from
+* that spec demanded fields the server does not, and a spec-validating gateway
+* would have rejected partial updates the server accepts.
+*/
+function updateOperation(collection, schemaName, requireAuth) {
+	return {
+		tags: [collection.name],
+		summary: `Update ${collection.singularName || collection.name}`,
+		description: "Partial update: only the properties present in the body are written; the rest are left unchanged.",
+		operationId: `update${schemaName}`,
+		parameters: [{
+			name: "id",
+			in: "path",
+			required: true,
+			schema: { type: "string" },
+			description: "Entity ID"
+		}],
+		requestBody: {
+			required: true,
+			content: { "application/json": { schema: { $ref: `#/components/schemas/${schemaName}Update` } } }
+		},
+		responses: {
+			200: {
+				description: "Updated entity",
+				content: { "application/json": { schema: { $ref: `#/components/schemas/${schemaName}` } } }
+			},
+			404: {
+				description: "Entity not found",
+				content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } }
+			},
+			...errorResponses(requireAuth)
+		}
+	};
+}
+/**
+* The update body: the create schema with `required` dropped.
+*
+* Derived rather than rebuilt so the two cannot describe different columns —
+* the only difference between creating and updating is which fields you must
+* supply, and that is exactly the one thing removed here.
+*/
+function buildCollectionUpdateSchema(collection) {
+	const { required: _required, ...rest } = buildCollectionInputSchema(collection);
+	return rest;
+}
+/**
 * Build an input schema (for POST/PUT) — excludes auto-generated fields.
 */
 function buildCollectionInputSchema(collection) {
@@ -594,4 +806,4 @@ function toPascalCase(str) {
 //#endregion
 export { generateOpenApiSpec };
 
-//# sourceMappingURL=openapi-generator-BEwyiaAr.js.map
+//# sourceMappingURL=openapi-generator-VB0MUH8h.js.map