@rebasepro/server 0.13.0 → 0.13.1-canary.g18cfeb7

package/dist/{openapi-generator-BEwyiaAr.js → openapi-generator-CSlEZh7-.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-CvaxLgnM.js";
+import "./src-Ca6NhxKs.js";
 //#region ../types/src/types/relations.ts
 /** @group Models */
 function isToMany(relation) {
@@ -13,6 +13,95 @@ 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: "Full-text search query"
+		}
+	];
 	const spec = {
 		openapi: "3.0.3",
 		info: {
@@ -94,77 +183,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 +225,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 +405,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 +446,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 +496,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 +772,4 @@ function toPascalCase(str) {
 //#endregion
 export { generateOpenApiSpec };
 
-//# sourceMappingURL=openapi-generator-BEwyiaAr.js.map
+//# sourceMappingURL=openapi-generator-CSlEZh7-.js.map

package/dist/openapi-generator-CSlEZh7-.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi-generator-CSlEZh7-.js","names":[],"sources":["../../types/src/types/relations.ts","../src/api/openapi-generator.ts"],"sourcesContent":["import type { AnyCollectionConfig } from \"./collections\";\n\n/**\n * @group Models\n */\nexport type OnAction = \"cascade\" | \"restrict\" | \"no action\" | \"set null\" | \"set default\";\n\n/**\n * What kind of link a relation is.\n *\n * The discriminant. Every other field a relation carries belongs to exactly one\n * of these, which is the point: a relation used to be a single open interface\n * where `cardinality`, `direction`, `localKey`, `foreignKeyOnTarget`, `through`\n * and `joinPath` were all optional and any combination typechecked. Which link\n * you meant then had to be *inferred* from which fields you happened to set,\n * and the inference was ~200 lines that guessed, fell back on naming\n * conventions, and swallowed its own failures.\n *\n * Most of that guessing produced bugs rather than convenience. A `many`\n * relation carrying a `localKey` — a combination the old type permitted — made\n * the write path stamp the parent's own foreign key onto the child row. Under\n * these kinds that state cannot be written down.\n *\n * @group Models\n */\nexport type RelationKind = \"belongsTo\" | \"hasOne\" | \"hasMany\" | \"manyToMany\" | \"via\";\n\n/** Fields every relation carries, whatever its kind. @group Models */\nexport interface RelationBase {\n    /**\n     * The name this link is addressed by: the key in `include`, the tab in the\n     * admin panel, and the path segment of a nested URL.\n     *\n     * Defaults to the declaring property's key, or to the target's slug for an\n     * entry in `relations`.\n     */\n    relationName?: string;\n\n    /** The collection on the other end. */\n    target: () => AnyCollectionConfig;\n\n    onUpdate?: OnAction;\n    onDelete?: OnAction;\n\n    /** Presentation overrides applied when this relation is rendered as a tab. */\n    overrides?: Partial<AnyCollectionConfig>;\n\n    validation?: {\n        required?: boolean;\n    };\n}\n\n/**\n * This collection holds the foreign key. One target row per source row.\n *\n * ```ts\n * author: { kind: \"belongsTo\", target: () => authors, localKey: \"author_id\" }\n * ```\n * @group Models\n */\nexport interface BelongsToRelation extends RelationBase {\n    kind: \"belongsTo\";\n    /**\n     * Column on **this** collection's table holding the target's key.\n     * Defaults to `<relationName>_id`.\n     */\n    localKey?: string;\n}\n\n/**\n * The target holds the foreign key, and at most one target row points back.\n *\n * ```ts\n * profile: { kind: \"hasOne\", target: () => profiles, foreignKeyOnTarget: \"user_id\" }\n * ```\n * @group Models\n */\nexport interface HasOneRelation extends RelationBase {\n    kind: \"hasOne\";\n    /**\n     * Column on the **target's** table holding this collection's key.\n     * Defaults to `<thisCollection>_id`.\n     */\n    foreignKeyOnTarget?: string;\n    /**\n     * Column on **this** collection's table whose value `foreignKeyOnTarget`\n     * holds. Defaults to this collection's primary key.\n     *\n     * Set it when the two sides are joined on a natural key rather than on the\n     * row id — an external identity id, a SKU, a tenant slug. See\n     * {@link HasManyRelation.sourceKey}, which this mirrors.\n     */\n    sourceKey?: string;\n}\n\n/**\n * The target holds the foreign key, and many target rows point back. The\n * children belong to this parent alone — deleting one deletes a row.\n *\n * ```ts\n * posts: { kind: \"hasMany\", target: () => posts, foreignKeyOnTarget: \"author_id\" }\n * ```\n * @group Models\n */\nexport interface HasManyRelation extends RelationBase {\n    kind: \"hasMany\";\n    /**\n     * Column on the **target's** table holding this collection's key.\n     * Defaults to `<thisCollection>_id`.\n     */\n    foreignKeyOnTarget?: string;\n    /**\n     * Column on **this** collection's table whose value `foreignKeyOnTarget`\n     * holds. Defaults to this collection's primary key.\n     *\n     * The mirror of `localKey` on {@link BelongsToRelation}: that one names the\n     * column this side reads from, this one names the column the other side\n     * points at. Without it the pair can only be joined on the row id, which\n     * makes a natural-key link — `auth_user_id ↔ auth_user_id`, a SKU, a tenant\n     * slug — inexpressible as `hasMany`, and it has to drop to the read-only\n     * `via`.\n     *\n     * The column must be unique: the link addresses one source row per value,\n     * and Postgres will not accept a foreign key against a non-unique column.\n     *\n     * ```ts\n     * applications: {\n     *     kind: \"hasMany\",\n     *     target: () => talentApplications,\n     *     sourceKey: \"auth_user_id\",\n     *     foreignKeyOnTarget: \"auth_user_id\"\n     * }\n     * ```\n     */\n    sourceKey?: string;\n}\n\n/**\n * Both sides hold many, through a junction table. The target rows are shared,\n * so this collection owns the *link* and not the row: removing one removes a\n * junction row and leaves the target alone.\n *\n * Declared the same way from either side — there is no owning and inverse\n * version. Swap `sourceColumn` and `targetColumn` to describe the other\n * direction.\n *\n * ```ts\n * tags: { kind: \"manyToMany\", target: () => tags }\n * ```\n * @group Models\n */\nexport interface ManyToManyRelation extends RelationBase {\n    kind: \"manyToMany\";\n    /**\n     * The junction table and its two key columns. Every part defaults: the\n     * table to both table names sorted and joined, the columns to\n     * `<collection>_id` and `<relationName>_id`.\n     */\n    through?: {\n        table?: string;\n        /** Junction column holding **this** collection's key. */\n        sourceColumn?: string;\n        /** Junction column holding the **target's** key. */\n        targetColumn?: string;\n    };\n}\n\n/**\n * An explicit chain of joins, for links the four shapes above cannot express:\n * multi-hop paths, composite keys, or a join whose condition is not a plain\n * foreign key.\n *\n * Read-only. Rebase will not infer how to write through an arbitrary join\n * chain, and guessing is what this type exists to stop.\n *\n * ```ts\n * permissions: {\n *     kind: \"via\",\n *     target: () => permissions,\n *     cardinality: \"many\",\n *     joinPath: [\n *         { table: \"user_roles\",       on: { from: \"id\",            to: \"user_id\" } },\n *         { table: \"role_permissions\", on: { from: \"role_id\",       to: \"role_id\" } },\n *         { table: \"permissions\",      on: { from: \"permission_id\", to: \"id\" } }\n *     ]\n * }\n * ```\n * @group Models\n */\nexport interface ViaRelation extends RelationBase {\n    kind: \"via\";\n    /** Whether the chain yields one row or many. Cannot be derived from a join chain. */\n    cardinality: \"one\" | \"many\";\n    joinPath: JoinStep[];\n}\n\n/**\n * A link from one collection to another, as authored.\n *\n * A closed union: pick the kind that describes the link and the type offers\n * exactly the fields that kind needs. See {@link ResolvedRelation} for the form\n * the runtime works with, which has every default filled in.\n *\n * @group Models\n */\nexport type Relation =\n    | BelongsToRelation\n    | HasOneRelation\n    | HasManyRelation\n    | ManyToManyRelation\n    | ViaRelation;\n\n/**\n * A relation with every default filled in — the form the runtime works with.\n *\n * The authored {@link Relation} and this are deliberately different types.\n * They used to be one, which meant no reader could tell which fields had been\n * supplied and which had been guessed, and so every consumer re-derived what it\n * needed with its own chain of `if (through) … else if (localKey) …` fallbacks.\n * Those chains disagreed with each other; that disagreement is what produced\n * silently wrong reads and corrupt writes.\n *\n * Here each variant carries exactly its own fields, all required. A consumer\n * switches on `kind` and gets what it needs without a fallback, and the cases\n * it forgot are a compile error rather than a wrong answer at runtime.\n *\n * @group Models\n */\nexport type ResolvedRelation =\n    | ResolvedBelongsTo\n    | ResolvedHasOne\n    | ResolvedHasMany\n    | ResolvedManyToMany\n    | ResolvedVia;\n\n/** Fields present on every resolved relation. @group Models */\nexport interface ResolvedRelationBase {\n    /** Always set: defaulted during resolution if the author omitted it. */\n    relationName: string;\n    target: () => AnyCollectionConfig;\n    /** The target's slug, resolved once so consumers need not call `target()`. */\n    targetSlug: string;\n    onUpdate?: OnAction;\n    onDelete?: OnAction;\n    overrides?: Partial<AnyCollectionConfig>;\n    validation?: { required?: boolean };\n    /**\n     * Whether one row or many come back. Derived from `kind` — kept because it\n     * is what most consumers actually branch on, and because `via` is the one\n     * kind where it is authored rather than implied.\n     */\n    cardinality: \"one\" | \"many\";\n    /**\n     * Whether Rebase knows how to write through this link. False only for\n     * {@link ResolvedVia}, whose join chain it will not invent a write for.\n     */\n    writable: boolean;\n    /**\n     * Whether the target rows are shared with other parents. True for\n     * many-to-many and for multi-hop `via`: what the parent owns is the link,\n     * so removing one must not delete the row.\n     */\n    shared: boolean;\n}\n\n/** @group Models */\nexport interface ResolvedBelongsTo extends ResolvedRelationBase {\n    kind: \"belongsTo\";\n    cardinality: \"one\";\n    writable: true;\n    shared: false;\n    /** Column on this collection's table. */\n    localKey: string;\n}\n\n/** @group Models */\nexport interface ResolvedHasOne extends ResolvedRelationBase {\n    kind: \"hasOne\";\n    cardinality: \"one\";\n    writable: true;\n    shared: false;\n    /** Column on the target's table. */\n    foreignKeyOnTarget: string;\n    /** @see ResolvedHasMany.sourceKey */\n    sourceKey?: string;\n}\n\n/** @group Models */\nexport interface ResolvedHasMany extends ResolvedRelationBase {\n    kind: \"hasMany\";\n    cardinality: \"many\";\n    writable: true;\n    shared: false;\n    /** Column on the target's table. */\n    foreignKeyOnTarget: string;\n    /**\n     * Column on the source's table that `foreignKeyOnTarget` points at, or\n     * `undefined` for the source's primary key.\n     *\n     * The one optional field on a resolved relation, and deliberately so. Every\n     * other default is filled in here because it can be: a table name and a\n     * column name are derivable from the relation and its two endpoints alone.\n     * The primary key is not — this driver resolves it from `isId`, then the\n     * Drizzle schema, then a column named `id`, and the middle tier does not\n     * exist at resolution time.\n     *\n     * So `undefined` is a sentinel with exactly one meaning, not a field a\n     * consumer is invited to guess at. Read it through `sourceKeyField()`,\n     * which is the only place that turns it into a column name.\n     */\n    sourceKey?: string;\n}\n\n/** @group Models */\nexport interface ResolvedManyToMany extends ResolvedRelationBase {\n    kind: \"manyToMany\";\n    cardinality: \"many\";\n    writable: true;\n    shared: true;\n    through: {\n        table: string;\n        sourceColumn: string;\n        targetColumn: string;\n    };\n}\n\n/** @group Models */\nexport interface ResolvedVia extends ResolvedRelationBase {\n    kind: \"via\";\n    writable: false;\n    joinPath: JoinStep[];\n}\n\n// ── Narrowing helpers ────────────────────────────────────────────────\n//\n// Consumers that only care about one axis — \"does this list many rows\",\n// \"is there a column on the target\" — should ask that question rather\n// than enumerate kinds, so adding a kind later does not silently skip them.\n\n/** Relations whose target row carries this collection's key. @group Models */\nexport type ResolvedForeignKeyOnTarget = ResolvedHasOne | ResolvedHasMany;\n\n/** @group Models */\nexport function hasForeignKeyOnTarget(relation: ResolvedRelation): relation is ResolvedForeignKeyOnTarget {\n    return relation.kind === \"hasOne\" || relation.kind === \"hasMany\";\n}\n\n/** @group Models */\nexport function isManyToMany(relation: ResolvedRelation): relation is ResolvedManyToMany {\n    return relation.kind === \"manyToMany\";\n}\n\n/** @group Models */\nexport function isToMany(relation: ResolvedRelation): boolean {\n    return relation.cardinality === \"many\";\n}\n\n/**\n * Defines a single, explicit step in a multi-join path.\n *\n * Each step represents one JOIN operation in the sequence. The `from` columns\n * refer to the previous table in the chain (or the source table for the first step),\n * and the `to` columns refer to the current table being joined.\n *\n * @example Single column join:\n * ```typescript\n * {\n *   table: \"authors\",\n *   on: {\n *     from: \"author_id\",  // Column from previous table (e.g., posts.author_id)\n *     to: \"id\"           // Column from current table (authors.id)\n *   }\n * }\n * ```\n *\n * @example Multi-column composite key join:\n * ```typescript\n * {\n *   table: \"order_items\",\n *   on: {\n *     from: [\"order_id\", \"store_id\"],    // Multiple columns from previous table\n *     to: [\"order_id\", \"store_id\"]       // Corresponding columns in current table\n *   }\n * }\n * ```\n */\nexport interface JoinStep {\n    /**\n     * The database table name to join TO in this step.\n     * This is the table you're joining into, not the table you're joining from.\n     *\n     * @example \"authors\", \"user_roles\", \"product_categories\"\n     */\n    table: string;\n\n    /**\n     * The join condition for this step. Defines how the previous table\n     * connects to the current table.\n     *\n     * - `from`: Column name(s) on the PREVIOUS table in the join chain\n     * - `to`: Column name(s) on the CURRENT table (specified in `table`)\n     *\n     * For the first step, `from` refers to the source collection's table.\n     * For subsequent steps, `from` refers to the table from the previous step.\n     *\n     * Both `from` and `to` support:\n     * - Single column: `\"user_id\"`\n     * - Multiple columns: `[\"company_id\", \"region_id\"]` for composite keys\n     *\n     * When using arrays, both `from` and `to` must have the same length,\n     * and columns are matched by position (index 0 with index 0, etc.).\n     */\n    on: {\n        from: string | string[];\n        to: string | string[];\n    };\n}\n","import { CollectionConfig, Property, StringProperty, NumberProperty, ArrayProperty, MapProperty, isToMany, VectorProperty, DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT } from \"@rebasepro/types\";\nimport { resolveCollectionRelations } from \"@rebasepro/common\";\n\n/**\n * OpenAPI 3.0.3 specification generator.\n *\n * Produces a spec that exactly mirrors the REST API consumed by the\n * Rebase SDK client (`@rebasepro/client`).\n *\n * Routes are mounted at `{basePath}/data/{slug}` by `initializeRebaseBackend`.\n */\n\nexport interface OpenApiGeneratorOptions {\n    /** Base path for the API (e.g. \"/api\"). Defaults to \"/api\". */\n    basePath?: string;\n    /** Whether auth is enabled on data routes. Defaults to true. */\n    requireAuth?: boolean;\n    /**\n     * The list-pagination bounds the REST layer applies, so the spec states the\n     * ones a request will actually meet.\n     *\n     * These were hardcoded as `default: 20, maximum: 100` — neither of which\n     * the server has ever used. The spec drives the API Explorer and is what a\n     * generated client is built from, so an understated ceiling is a request\n     * the client refuses to make, and an overstated one is a 400 nobody\n     * predicted.\n     */\n    listLimits?: { defaultLimit?: number; maxLimit?: number };\n}\n\nexport function generateOpenApiSpec(\n    collections: CollectionConfig[],\n    options: OpenApiGeneratorOptions = {}\n): Record<string, unknown> {\n    const basePath = options.basePath ?? \"/api\";\n    const requireAuth = options.requireAuth ?? true;\n    const defaultLimit = options.listLimits?.defaultLimit ?? DEFAULT_LIST_LIMIT;\n    const maxLimit = options.listLimits?.maxLimit ?? MAX_LIST_LIMIT;\n\n    /**\n     * The query parameters every list endpoint honours.\n     *\n     * Written once because it was written twice: the root listing named eight\n     * and the subcollection listing named four, though both go through the same\n     * `parseQueryOptions` and the same fetch. Four capabilities were therefore\n     * unreachable from a generated client on nested routes, and `or`/`and` were\n     * undocumented on both.\n     */\n    const listQueryParameters = () => [\n        { name: \"limit\", in: \"query\", schema: { type: \"integer\", default: defaultLimit, maximum: maxLimit },\n            description: \"Maximum number of records to return\" },\n        { name: \"offset\", in: \"query\", schema: { type: \"integer\", default: 0 },\n            description: \"Number of records to skip\" },\n        { name: \"page\", in: \"query\", schema: { type: \"integer\", minimum: 1 },\n            description: \"Page number (alternative to offset). Calculates offset as (page-1)*limit\" },\n        {\n            name: \"orderBy\",\n            in: \"query\",\n            schema: { type: \"string\" },\n            description: \"Sort field and direction. Accepts `field:asc` or `field:desc`, or a JSON array `[{\\\"field\\\":\\\"name\\\",\\\"direction\\\":\\\"asc\\\"}]`\",\n            example: \"created_at:desc\"\n        },\n        {\n            name: \"where\",\n            in: \"query\",\n            schema: { type: \"string\" },\n            description: \"JSON object filter, mapping each field to a `[operator, value]` tuple. \"\n                + \"Combines with the per-field `?field=op.value` parameters below; on the same field, the per-field parameter wins.\",\n            example: \"{\\\"status\\\":[\\\"==\\\",\\\"active\\\"]}\"\n        },\n        {\n            name: \"or\",\n            in: \"query\",\n            schema: { type: \"string\" },\n            description: \"Disjunction of conditions, AND-ed with `where` and `searchString`.\",\n            example: \"(status.eq.draft,status.eq.review)\"\n        },\n        {\n            name: \"and\",\n            in: \"query\",\n            schema: { type: \"string\" },\n            description: \"Conjunction of conditions, AND-ed with `where` and `searchString`. Ignored when `or` is also present.\",\n            example: \"(views.gte.10,status.eq.draft)\"\n        },\n        {\n            name: \"include\",\n            in: \"query\",\n            schema: { type: \"string\" },\n            description: \"Comma-separated list of relations to include (eager-load). Use `*` for all relations.\",\n            example: \"author,tags\"\n        },\n        {\n            name: \"fields\",\n            in: \"query\",\n            schema: { type: \"string\" },\n            description: \"Comma-separated list of fields to return (field selection)\",\n            example: \"id,name,created_at\"\n        },\n        {\n            name: \"searchString\",\n            in: \"query\",\n            schema: { type: \"string\" },\n            description: \"Full-text search query\"\n        }\n    ];\n\n    const spec: Record<string, unknown> = {\n        openapi: \"3.0.3\",\n        info: {\n            title: \"Rebase API\",\n            version: \"1.0.0\",\n            description:\n                \"Auto-generated REST API from Rebase collection definitions. \" +\n                \"This is the same API consumed by the `@rebasepro/client` SDK.\"\n        },\n        servers: [\n            {\n                url: basePath,\n                description: \"API Server\"\n            }\n        ],\n        paths: {} as Record<string, unknown>,\n        components: {\n            schemas: {\n                ErrorResponse: {\n                    type: \"object\",\n                    properties: {\n                        error: {\n                            type: \"object\",\n                            required: [\"message\", \"code\"],\n                            properties: {\n                                message: { type: \"string\" },\n                                code: { type: \"string\" },\n                                details: {}\n                            }\n                        }\n                    }\n                },\n                PaginationMeta: {\n                    type: \"object\",\n                    properties: {\n                        total: { type: \"integer\",\ndescription: \"Total number of matching records\" },\n                        limit: { type: \"integer\",\ndescription: \"Page size used for this query\" },\n                        offset: { type: \"integer\",\ndescription: \"Number of records skipped\" },\n                        hasMore: { type: \"boolean\",\ndescription: \"Whether more records exist beyond this page\" }\n                    }\n                }\n            } as Record<string, unknown>,\n            securitySchemes: {} as Record<string, unknown>\n        },\n        tags: [] as Array<{ name: string; description?: string }>\n    };\n\n    // ── Security Schemes ─────────────────────────────────────────────────\n    if (requireAuth) {\n        (spec.components as Record<string, unknown>).securitySchemes = {\n            bearerAuth: {\n                type: \"http\",\n                scheme: \"bearer\",\n                bearerFormat: \"JWT\",\n                description:\n                    \"JWT access token obtained from `POST /auth/login` or `POST /auth/register`. \" +\n                    \"Can also be a static service key for server-to-server authentication.\"\n            },\n            queryToken: {\n                type: \"apiKey\",\n                in: \"query\",\n                name: \"token\",\n                description: \"Alternative: pass the JWT or service key as a `token` query parameter.\"\n            }\n        };\n        (spec as Record<string, unknown>).security = [\n            { bearerAuth: [] },\n            { queryToken: [] }\n        ];\n    }\n\n    const paths = spec.paths as Record<string, unknown>;\n    const schemas = (spec.components as Record<string, unknown>).schemas as Record<string, unknown>;\n    const tags = spec.tags as Array<{ name: string; description?: string }>;\n\n    // ── Collection routes ────────────────────────────────────────────────\n    for (const collection of (collections || [])) {\n        const schemaName = toPascalCase(collection.singularName || collection.name);\n        const slug = collection.slug;\n\n        tags.push({\n            name: collection.name,\n            description: collection.description || `CRUD operations for ${collection.name}`\n        });\n\n        // Build component schema for this collection\n        schemas[schemaName] = buildCollectionSchema(collection);\n\n        // Build an \"input\" schema (no read-only/auto fields like autoValue dates)\n        schemas[`${schemaName}Input`] = buildCollectionInputSchema(collection);\n\n        // The update body — same columns, no `required`. PATCH and PUT both\n        // merge, so a field left out means \"unchanged\", not \"omitted by mistake\".\n        schemas[`${schemaName}Update`] = buildCollectionUpdateSchema(collection);\n\n        const dataPath = `/data/${slug}`;\n\n        // ── GET /data/{slug} — List entities ──────────────────────────\n        paths[dataPath] = {\n            get: {\n                tags: [collection.name],\n                summary: `List ${collection.name}`,\n                operationId: `list${schemaName}`,\n                parameters: [\n                    ...listQueryParameters(),\n                    ...buildFilterParameters(collection)\n                ],\n                responses: {\n                    200: {\n                        description: \"Paginated list of entities\",\n                        content: {\n                            \"application/json\": {\n                                schema: {\n                                    type: \"object\",\n                                    properties: {\n                                        data: {\n                                            type: \"array\",\n                                            items: { $ref: `#/components/schemas/${schemaName}` }\n                                        },\n                                        meta: { $ref: \"#/components/schemas/PaginationMeta\" }\n                                    }\n                                }\n                            }\n                        }\n                    },\n                    ...errorResponses(requireAuth)\n                }\n            },\n            post: {\n                tags: [collection.name],\n                summary: `Create ${collection.singularName || collection.name}`,\n                operationId: `create${schemaName}`,\n                requestBody: {\n                    required: true,\n                    content: {\n                        \"application/json\": {\n                            schema: { $ref: `#/components/schemas/${schemaName}Input` }\n                        }\n                    }\n                },\n                responses: {\n                    201: {\n                        description: \"Created entity\",\n                        content: {\n                            \"application/json\": {\n                                schema: { $ref: `#/components/schemas/${schemaName}` }\n                            }\n                        }\n                    },\n                    ...errorResponses(requireAuth)\n                }\n            }\n        };\n\n        // ── Bulk: one transaction, all-or-nothing ─────────────────────\n        //\n        // These went undocumented while they existed, which is the same defect\n        // the update verb had: an endpoint the server serves and the spec does\n        // not mention cannot be reached by a generated client at all.\n        const idempotencyHeader = {\n            name: \"Idempotency-Key\",\n            in: \"header\",\n            required: false,\n            schema: { type: \"string\" },\n            description:\n                \"Names this write so a retry is recognised instead of repeated. Without it a \" +\n                \"client that lost the response cannot distinguish a replay from a second \" +\n                \"genuine batch, and the whole batch is written twice.\"\n        };\n\n        const bulkErrors = {\n            400: {\n                description: \"Malformed body, an unknown field, or more rows than the per-batch limit\",\n                content: { \"application/json\": { schema: { $ref: \"#/components/schemas/ErrorResponse\" } } }\n            },\n            409: {\n                description: \"A request with the same Idempotency-Key is still in flight\",\n                content: { \"application/json\": { schema: { $ref: \"#/components/schemas/ErrorResponse\" } } }\n            },\n            ...errorResponses(requireAuth)\n        };\n\n        paths[`/data/${slug}/bulk`] = {\n            post: {\n                tags: [collection.name],\n                summary: `Create many ${collection.name} in one transaction`,\n                description:\n                    \"All-or-nothing: if any row is rejected none of them land, and the error names \" +\n                    \"the offending index. Every row still runs callbacks, relations and row-level \" +\n                    \"security. Capped server-side because one batch holds its locks for its whole \" +\n                    \"duration.\",\n                operationId: `createMany${schemaName}`,\n                parameters: [idempotencyHeader],\n                requestBody: {\n                    required: true,\n                    content: {\n                        \"application/json\": {\n                            schema: {\n                                type: \"object\",\n                                required: [\"rows\"],\n                                properties: {\n                                    rows: { type: \"array\", items: { $ref: `#/components/schemas/${schemaName}Input` } },\n                                    upsert: {\n                                        type: \"boolean\",\n                                        description: \"Write each row as INSERT ... ON CONFLICT DO UPDATE on the primary key.\"\n                                    }\n                                }\n                            }\n                        }\n                    }\n                },\n                responses: {\n                    200: {\n                        description: \"The written rows, in the order given\",\n                        content: {\n                            \"application/json\": {\n                                schema: {\n                                    type: \"object\",\n                                    properties: {\n                                        data: { type: \"array\", items: { $ref: `#/components/schemas/${schemaName}` } },\n                                        meta: { type: \"object\", properties: { written: { type: \"integer\" } } }\n                                    }\n                                }\n                            }\n                        }\n                    },\n                    ...bulkErrors\n                }\n            },\n            patch: {\n                tags: [collection.name],\n                summary: `Update many ${collection.name} in one transaction`,\n                description:\n                    \"Each entry names its row and the fields to change. `{ id, data }` rather than \" +\n                    \"flat rows carrying their own key, because on a table keyed on something other \" +\n                    \"than `id` a flat row cannot say whether a column is the address or a value to \" +\n                    \"write. An id matching no row fails the batch.\",\n                operationId: `updateMany${schemaName}`,\n                parameters: [idempotencyHeader],\n                requestBody: {\n                    required: true,\n                    content: {\n                        \"application/json\": {\n                            schema: {\n                                type: \"object\",\n                                required: [\"updates\"],\n                                properties: {\n                                    updates: {\n                                        type: \"array\",\n                                        items: {\n                                            type: \"object\",\n                                            required: [\"id\", \"data\"],\n                                            properties: {\n                                                id: { type: \"string\", description: \"The row to update\" },\n                                                data: { $ref: `#/components/schemas/${schemaName}Update` }\n                                            }\n                                        }\n                                    }\n                                }\n                            }\n                        }\n                    }\n                },\n                responses: {\n                    200: {\n                        description: \"The updated rows, in the order given\",\n                        content: {\n                            \"application/json\": {\n                                schema: {\n                                    type: \"object\",\n                                    properties: {\n                                        data: { type: \"array\", items: { $ref: `#/components/schemas/${schemaName}` } },\n                                        meta: { type: \"object\", properties: { written: { type: \"integer\" } } }\n                                    }\n                                }\n                            }\n                        }\n                    },\n                    404: {\n                        description: \"One of the ids matches no row; nothing was written\",\n                        content: { \"application/json\": { schema: { $ref: \"#/components/schemas/ErrorResponse\" } } }\n                    },\n                    ...bulkErrors\n                }\n            }\n        };\n\n        paths[`/data/${slug}/bulk/delete`] = {\n            post: {\n                tags: [collection.name],\n                summary: `Delete many ${collection.name} in one transaction`,\n                description:\n                    \"A POST, not `DELETE /bulk` with a body. Bodies on DELETE are permitted but \" +\n                    \"widely dropped by proxies and CDNs, and several generators ignore \" +\n                    \"`requestBody` on a DELETE operation — a generated client would send the \" +\n                    \"request with no ids at all. Takes ids rather than a filter: a mistyped \" +\n                    \"condition that empties a table cannot be reviewed at the call site the way \" +\n                    \"an explicit list can. `beforeDelete`/`afterDelete` fire per row.\",\n                operationId: `deleteMany${schemaName}`,\n                parameters: [idempotencyHeader],\n                requestBody: {\n                    required: true,\n                    content: {\n                        \"application/json\": {\n                            schema: {\n                                type: \"object\",\n                                required: [\"ids\"],\n                                properties: {\n                                    ids: {\n                                        type: \"array\",\n                                        items: { oneOf: [{ type: \"string\" }, { type: \"integer\" }] }\n                                    }\n                                }\n                            }\n                        }\n                    }\n                },\n                responses: {\n                    200: {\n                        description: \"How many rows were deleted\",\n                        content: {\n                            \"application/json\": {\n                                schema: {\n                                    type: \"object\",\n                                    properties: {\n                                        meta: { type: \"object\", properties: { deleted: { type: \"integer\" } } }\n                                    }\n                                }\n                            }\n                        }\n                    },\n                    404: {\n                        description: \"One of the ids matches no row; nothing was deleted\",\n                        content: { \"application/json\": { schema: { $ref: \"#/components/schemas/ErrorResponse\" } } }\n                    },\n                    ...bulkErrors\n                }\n            }\n        };\n\n        // ── GET/PUT/DELETE /data/{slug}/{id} ──────────────────────────\n        const entityPath = `/data/${slug}/{id}`;\n        paths[entityPath] = {\n            get: {\n                tags: [collection.name],\n                summary: `Get ${collection.singularName || collection.name} by ID`,\n                operationId: `get${schemaName}ById`,\n                parameters: [\n                    { name: \"id\",\nin: \"path\",\nrequired: true,\nschema: { type: \"string\" },\ndescription: \"Entity ID\" },\n                    {\n                        name: \"include\",\n                        in: \"query\",\n                        schema: { type: \"string\" },\n                        description: \"Comma-separated list of relations to include\",\n                        example: \"author,tags\"\n                    }\n                ],\n                responses: {\n                    200: {\n                        description: \"Entity found\",\n                        content: {\n                            \"application/json\": {\n                                schema: { $ref: `#/components/schemas/${schemaName}` }\n                            }\n                        }\n                    },\n                    404: { description: \"Entity not found\",\ncontent: { \"application/json\": { schema: { $ref: \"#/components/schemas/ErrorResponse\" } } } },\n                    ...errorResponses(requireAuth)\n                }\n            },\n            patch: updateOperation(collection, schemaName, requireAuth),\n            // Same operation under the verb every published SDK already sends.\n            // Kept so existing clients keep validating; `patch` is the one to\n            // generate against.\n            put: {\n                ...updateOperation(collection, schemaName, requireAuth),\n                operationId: `update${schemaName}ViaPut`,\n                deprecated: true\n            },\n            delete: {\n                tags: [collection.name],\n                summary: `Delete ${collection.singularName || collection.name}`,\n                operationId: `delete${schemaName}`,\n                parameters: [\n                    { name: \"id\",\nin: \"path\",\nrequired: true,\nschema: { type: \"string\" },\ndescription: \"Entity ID\" }\n                ],\n                responses: {\n                    204: { description: \"Deleted successfully\" },\n                    404: { description: \"Entity not found\",\ncontent: { \"application/json\": { schema: { $ref: \"#/components/schemas/ErrorResponse\" } } } },\n                    ...errorResponses(requireAuth)\n                }\n            }\n        };\n\n    }\n\n    // ── Subcollection routes ─────────────────────────────────────────────\n    //\n    // A second pass, after every collection's component schema exists. These\n    // routes `$ref` the *target's* schema, and the first pass builds schemas in\n    // array order — so doing this inline meant a subcollection whose target\n    // appeared later in the list silently degraded to an untyped `object`.\n    //\n    // The names come from the *resolved* relations, not from the authored\n    // `relations` array. `relationName` is optional at the authoring surface —\n    // it defaults to the property key, or to the target's slug — so reading the\n    // raw field skipped every relation that relied on the default, and missed\n    // relations declared inline on a property entirely, since those are not in\n    // the array. These are the same resolved names the nested-path router\n    // matches, so the spec and the routes cannot drift apart.\n    //\n    // A to-one relation is left out. `posts/1/author` resolves, but it\n    // addresses a single row, and documenting it as a paginated list would\n    // describe a response shape the client never gets.\n    for (const collection of (collections || [])) {\n        const slug = collection.slug;\n        const schemaName = toPascalCase(collection.singularName || collection.name);\n        const relations = Object.values(resolveCollectionRelations(collection))\n            .filter(isToMany);\n        for (const relation of relations) {\n            const relationName = relation.relationName;\n            const targetCollection = relation.target();\n            const targetName = targetCollection.singularName || targetCollection.name;\n            const targetSchema = toPascalCase(targetName);\n\n            const subPath = `/data/${slug}/{parentId}/${relationName}`;\n\n            // Only add if the schema exists (target collection is also registered)\n            paths[subPath] = {\n                get: {\n                    tags: [collection.name],\n                    summary: `List ${relationName} for ${withIndefiniteArticle(collection.singularName || collection.name)}`,\n                    operationId: `list${schemaName}${toPascalCase(relationName)}`,\n                    parameters: [\n                        { name: \"parentId\",\nin: \"path\",\nrequired: true,\nschema: { type: \"string\" },\ndescription: `${collection.singularName || collection.name} ID` },\n                        // The nested list handler goes through the same\n                        // `parseQueryOptions` and the same fetch as the root\n                        // one, so it honours the same parameters. It documented\n                        // four of them.\n                        ...listQueryParameters()\n                    ],\n                    responses: {\n                        200: {\n                            description: `List of related ${relationName}`,\n                            content: {\n                                \"application/json\": {\n                                    schema: {\n                                        type: \"object\",\n                                        properties: {\n                                            data: {\n                                                type: \"array\",\n                                                items: schemas[targetSchema]\n                                                    ? { $ref: `#/components/schemas/${targetSchema}` }\n                                                    : { type: \"object\" }\n                                            },\n                                            meta: { $ref: \"#/components/schemas/PaginationMeta\" }\n                                        }\n                                    }\n                                }\n                            }\n                        },\n                        ...errorResponses(requireAuth)\n                    }\n                }\n            };\n        }\n    }\n\n    return spec;\n}\n\n// ── Helpers ──────────────────────────────────────────────────────────────\n\n/**\n * Build the component schema for a collection (output / read shape).\n * All fields are included (including relation foreign keys).\n */\nfunction buildCollectionSchema(collection: CollectionConfig): Record<string, unknown> {\n    const properties: Record<string, unknown> = {\n        id: { type: \"string\",\ndescription: \"Unique identifier\" }\n    };\n    const required: string[] = [\"id\"];\n\n    for (const [key, property] of Object.entries(collection.properties)) {\n        // Skip relation properties — they are virtual and not part of the REST payload\n        if (property.type === \"relation\") continue;\n\n        properties[key] = convertPropertyToSchema(property);\n\n        if (property.validation?.required) {\n            required.push(key);\n        }\n    }\n\n    return {\n        type: \"object\",\n        required: required.length > 0 ? required : undefined,\n        properties\n    };\n}\n\n/**\n * The PATCH/PUT operation for `/data/{slug}/{id}`.\n *\n * Split out because both verbs serve it and they must not drift: the update\n * body is a **partial**, and describing it with the create schema was the bug\n * this replaces. `<Name>Input` marks every `validation.required` property as\n * required — correct for POST, wrong for an update, where omitting a field\n * means \"leave it alone\" rather than \"I forgot it\". A client generated from\n * that spec demanded fields the server does not, and a spec-validating gateway\n * would have rejected partial updates the server accepts.\n */\nfunction updateOperation(\n    collection: CollectionConfig,\n    schemaName: string,\n    requireAuth: boolean\n): Record<string, unknown> {\n    return {\n        tags: [collection.name],\n        summary: `Update ${collection.singularName || collection.name}`,\n        description: \"Partial update: only the properties present in the body are written; the rest are left unchanged.\",\n        operationId: `update${schemaName}`,\n        parameters: [\n            { name: \"id\", in: \"path\", required: true, schema: { type: \"string\" }, description: \"Entity ID\" }\n        ],\n        requestBody: {\n            required: true,\n            content: {\n                \"application/json\": {\n                    schema: { $ref: `#/components/schemas/${schemaName}Update` }\n                }\n            }\n        },\n        responses: {\n            200: {\n                description: \"Updated entity\",\n                content: {\n                    \"application/json\": {\n                        schema: { $ref: `#/components/schemas/${schemaName}` }\n                    }\n                }\n            },\n            404: {\n                description: \"Entity not found\",\n                content: { \"application/json\": { schema: { $ref: \"#/components/schemas/ErrorResponse\" } } }\n            },\n            ...errorResponses(requireAuth)\n        }\n    };\n}\n\n/**\n * The update body: the create schema with `required` dropped.\n *\n * Derived rather than rebuilt so the two cannot describe different columns —\n * the only difference between creating and updating is which fields you must\n * supply, and that is exactly the one thing removed here.\n */\nfunction buildCollectionUpdateSchema(collection: CollectionConfig): Record<string, unknown> {\n    const { required: _required, ...rest } = buildCollectionInputSchema(collection);\n    return rest;\n}\n\n/**\n * Build an input schema (for POST/PUT) — excludes auto-generated fields.\n */\nfunction buildCollectionInputSchema(collection: CollectionConfig): Record<string, unknown> {\n    const properties: Record<string, unknown> = {};\n    const required: string[] = [];\n\n    for (const [key, property] of Object.entries(collection.properties)) {\n        if (property.type === \"relation\") continue;\n\n        // Skip auto-value date fields from the input schema\n        if (property.type === \"date\" && property.autoValue) continue;\n\n        // Skip auto-generated ID fields\n        if (\"isId\" in property && property.isId && property.isId !== \"manual\" && property.isId !== true) continue;\n\n        properties[key] = convertPropertyToSchema(property);\n\n        if (property.validation?.required) {\n            required.push(key);\n        }\n    }\n\n    // Allow explicit ID for create (optional)\n    properties[\"id\"] = {\n        type: \"string\",\n        description: \"Optional: client-assigned ID. If omitted, the server generates one.\"\n    };\n\n    return {\n        type: \"object\",\n        required: required.length > 0 ? required : undefined,\n        properties\n    };\n}\n\n/**\n * Convert a Rebase Property to an OpenAPI 3.0 schema object.\n */\nfunction convertPropertyToSchema(property: Property): Record<string, unknown> {\n    const base: Record<string, unknown> = {};\n\n    if (property.name) {\n        base.description = property.name;\n    }\n\n    switch (property.type) {\n        case \"string\": {\n            const sp = property as StringProperty;\n            base.type = \"string\";\n\n            if (sp.enum) {\n                const enumValues = resolveEnumValues(sp.enum);\n                if (enumValues.length > 0) {\n                    base.enum = enumValues;\n                }\n            }\n\n            if (sp.validation) {\n                if (sp.validation.min !== undefined) base.minLength = sp.validation.min;\n                if (sp.validation.max !== undefined) base.maxLength = sp.validation.max;\n                if (sp.validation.length !== undefined) {\n                    base.minLength = sp.validation.length;\n                    base.maxLength = sp.validation.length;\n                }\n                if (sp.validation.matches !== undefined) {\n                    base.pattern = String(sp.validation.matches);\n                }\n            }\n\n            if (sp.email) base.format = \"email\";\n            if (sp.url) base.format = \"uri\";\n            if (sp.storage) base.format = \"uri\";\n\n            return base;\n        }\n\n        case \"number\": {\n            const np = property as NumberProperty;\n            const isInteger = np.validation?.integer || np.columnType === \"integer\" || np.columnType === \"serial\" || np.columnType === \"bigserial\" || np.columnType === \"bigint\";\n            base.type = isInteger ? \"integer\" : \"number\";\n\n            if (np.enum) {\n                const enumValues = resolveEnumValues(np.enum);\n                if (enumValues.length > 0) {\n                    base.enum = enumValues;\n                }\n            }\n\n            if (np.validation) {\n                if (np.validation.min !== undefined) base.minimum = np.validation.min;\n                if (np.validation.max !== undefined) base.maximum = np.validation.max;\n                if (np.validation.moreThan !== undefined) {\n                    base.minimum = np.validation.moreThan;\n                    base.exclusiveMinimum = true;\n                }\n                if (np.validation.lessThan !== undefined) {\n                    base.maximum = np.validation.lessThan;\n                    base.exclusiveMaximum = true;\n                }\n            }\n\n            return base;\n        }\n\n        case \"boolean\":\n            base.type = \"boolean\";\n            return base;\n\n        case \"date\": {\n            base.type = \"string\";\n            if (property.mode === \"date\") {\n                base.format = \"date\";\n            } else {\n                base.format = \"date-time\";\n            }\n            if (property.autoValue) {\n                base.readOnly = true;\n                base.description = (base.description || \"\") +\n                    (property.autoValue === \"on_create\" ? \" (Auto-set on creation)\" : \" (Auto-updated)\");\n            }\n            return base;\n        }\n\n        case \"geopoint\":\n            base.type = \"object\";\n            base.properties = {\n                latitude: { type: \"number\" },\n                longitude: { type: \"number\" }\n            };\n            base.required = [\"latitude\", \"longitude\"];\n            return base;\n\n        case \"reference\":\n            base.type = \"string\";\n            base.description = (base.description || \"\") + \" (Reference ID)\";\n            return base;\n\n        case \"array\": {\n            const ap = property as ArrayProperty;\n            base.type = \"array\";\n\n            if (ap.oneOf) {\n                // Discriminated union (e.g., content blocks)\n                const typeField = ap.oneOf.typeField || \"type\";\n                const valueField = ap.oneOf.valueField || \"value\";\n                const variants: Record<string, unknown>[] = [];\n\n                for (const [variantKey, variantProp] of Object.entries(ap.oneOf.properties)) {\n                    variants.push({\n                        type: \"object\",\n                        properties: {\n                            [typeField]: { type: \"string\",\nenum: [variantKey] },\n                            [valueField]: convertPropertyToSchema(variantProp)\n                        },\n                        required: [typeField, valueField]\n                    });\n                }\n\n                base.items = { oneOf: variants };\n            } else if (ap.of) {\n                if (Array.isArray(ap.of)) {\n                    base.items = { oneOf: ap.of.map(p => convertPropertyToSchema(p)) };\n                } else {\n                    base.items = convertPropertyToSchema(ap.of);\n                }\n            } else {\n                base.items = {};\n            }\n\n            if (ap.validation) {\n                if (ap.validation.min !== undefined) base.minItems = ap.validation.min;\n                if (ap.validation.max !== undefined) base.maxItems = ap.validation.max;\n            }\n\n            return base;\n        }\n\n        case \"map\": {\n            const mp = property as MapProperty;\n            base.type = \"object\";\n\n            if (mp.properties) {\n                const props: Record<string, unknown> = {};\n                const req: string[] = [];\n\n                for (const [key, subProp] of Object.entries(mp.properties)) {\n                    props[key] = convertPropertyToSchema(subProp);\n                    if (subProp.validation?.required) {\n                        req.push(key);\n                    }\n                }\n\n                base.properties = props;\n                if (req.length > 0) base.required = req;\n            } else if (mp.keyValue) {\n                base.additionalProperties = true;\n            }\n\n            return base;\n        }\n\n        case \"vector\": {\n            const vp = property as VectorProperty;\n            base.type = \"array\";\n            base.items = { type: \"number\" };\n            base.description = (base.description || \"\") + ` (Vector(${vp.dimensions}))`;\n            return base;\n        }\n        case \"binary\": {\n            base.type = \"string\";\n            base.description = (base.description || \"\") + \" (Binary/Base64)\";\n            return base;\n        }\n        default:\n            base.type = \"string\";\n            return base;\n    }\n}\n\n/**\n * Resolve EnumValues (array or record) into a flat array of enum values.\n */\nfunction resolveEnumValues(enumDef: Record<string | number, unknown> | Array<{ id: string | number }>): Array<string | number> {\n    if (Array.isArray(enumDef)) {\n        return enumDef.map(e => (typeof e === \"object\" && e !== null && \"id\" in e) ? e.id : e as string | number);\n    }\n    return Object.keys(enumDef).map(k => {\n        // Preserve numeric keys as numbers\n        const num = Number(k);\n        return isNaN(num) ? k : num;\n    });\n}\n\n/**\n * Build PostgREST-style filter parameters for a collection.\n * These are additional query parameters like `?status=eq.active&price=gte.100`.\n */\nfunction buildFilterParameters(collection: CollectionConfig): Array<Record<string, unknown>> {\n    const params: Array<Record<string, unknown>> = [];\n\n    for (const [key, property] of Object.entries(collection.properties)) {\n        if (property.type === \"relation\" || property.type === \"map\" || property.type === \"array\" || property.type === \"geopoint\") {\n            continue;\n        }\n\n        params.push({\n            name: key,\n            in: \"query\",\n            required: false,\n            schema: { type: \"string\" },\n            description:\n                `Filter by \\`${key}\\`. Supports PostgREST operators: ` +\n                \"`eq.value`, `neq.value`, `gt.value`, `gte.value`, `lt.value`, `lte.value`, \" +\n                \"`in.(a,b,c)`, `nin.(a,b,c)`, `cs.value` (array-contains), `csa.(a,b)` (array-contains-any). \" +\n                \"Plain values imply equality.\",\n            example: property.type === \"string\" ? \"eq.active\" : property.type === \"number\" ? \"gte.100\" : undefined\n        });\n    }\n\n    return params;\n}\n\n/**\n * Standard error responses included on every endpoint.\n */\nfunction errorResponses(requireAuth: boolean): Record<string, unknown> {\n    const responses: Record<string, unknown> = {\n        400: {\n            description: \"Bad request\",\n            content: { \"application/json\": { schema: { $ref: \"#/components/schemas/ErrorResponse\" } } }\n        },\n        500: {\n            description: \"Internal server error\",\n            content: { \"application/json\": { schema: { $ref: \"#/components/schemas/ErrorResponse\" } } }\n        }\n    };\n\n    if (requireAuth) {\n        responses[401] = {\n            description: \"Authentication required or invalid token\",\n            content: { \"application/json\": { schema: { $ref: \"#/components/schemas/ErrorResponse\" } } }\n        };\n        responses[403] = {\n            description: \"Insufficient permissions\",\n            content: { \"application/json\": { schema: { $ref: \"#/components/schemas/ErrorResponse\" } } }\n        };\n    }\n\n    return responses;\n}\n\n/**\n * Prefix a noun with \"a\" or \"an\" based on its leading sound.\n */\nfunction withIndefiniteArticle(noun: string): string {\n    return `${/^[aeiou]/i.test(noun) ? \"an\" : \"a\"} ${noun}`;\n}\n\n/**\n * Convert a string to PascalCase for schema names.\n */\nfunction toPascalCase(str: string): string {\n    return str\n        .replace(/[^a-zA-Z0-9]+/g, \" \")\n        .split(\" \")\n        .filter(Boolean)\n        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())\n        .join(\"\");\n}\n"],"mappings":"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"}