@rebasepro/server 0.13.0 → 0.13.1-canary.g06dbe5b

package/dist/openapi-generator-BQxxxDpb.js

@@ -0,0 +1,865 @@
+import { createRequire as __createRequire } from "module";
+import "process";
+__createRequire(import.meta.url);
+import { h as resolveCollectionRelations } from "./src-By48Ffg0.js";
+import "./src-Ca6NhxKs.js";
+//#region ../types/src/types/relations.ts
+/** @group Models */
+function isToMany(relation) {
+	return relation.cardinality === "many";
+}
+//#endregion
+//#region src/api/openapi-generator.ts
+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,
+				minimum: 1,
+				maximum: maxLimit
+			},
+			description: `Maximum number of records to return. Must be a whole number between 1 and ${maxLimit}; a larger one is rejected with 400 INVALID_LIMIT rather than trimmed, so a short page always means a short collection. Page past the ceiling with \`offset\`.`
+		},
+		{
+			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: {
+			title: "Rebase API",
+			version: "1.0.0",
+			description: "Auto-generated REST API from Rebase collection definitions. This is the same API consumed by the `@rebasepro/client` SDK."
+		},
+		servers: [{
+			url: basePath,
+			description: "API Server"
+		}],
+		paths: {},
+		components: {
+			schemas: {
+				ErrorResponse: {
+					type: "object",
+					properties: { error: {
+						type: "object",
+						required: ["message", "code"],
+						properties: {
+							message: { type: "string" },
+							code: { type: "string" },
+							details: {}
+						}
+					} }
+				},
+				PaginationMeta: {
+					type: "object",
+					properties: {
+						total: {
+							type: "integer",
+							description: "Total number of matching records"
+						},
+						limit: {
+							type: "integer",
+							description: "Page size used for this query"
+						},
+						offset: {
+							type: "integer",
+							description: "Number of records skipped"
+						},
+						hasMore: {
+							type: "boolean",
+							description: "Whether more records exist beyond this page"
+						}
+					}
+				}
+			},
+			securitySchemes: {}
+		},
+		tags: []
+	};
+	if (requireAuth) {
+		spec.components.securitySchemes = { bearerAuth: {
+			type: "http",
+			scheme: "bearer",
+			bearerFormat: "JWT",
+			description: "JWT access token obtained from `POST /auth/login` or `POST /auth/register`. Can also be a static service key for server-to-server authentication."
+		} };
+		spec.security = [{ bearerAuth: [] }];
+	}
+	const paths = spec.paths;
+	const schemas = spec.components.schemas;
+	const tags = spec.tags;
+	const reservedParameterNames = new Set(listQueryParameters().map((p) => p.name));
+	for (const collection of collections || []) {
+		const schemaName = schemaNameFor(collection);
+		const slug = collection.slug;
+		tags.push({
+			name: collection.name,
+			description: collection.description || `CRUD operations for ${collection.name}`
+		});
+		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: [...listQueryParameters(), ...buildFilterParameters(collection, reservedParameterNames)],
+				responses: {
+					200: {
+						description: "Paginated list of entities",
+						content: { "application/json": { schema: {
+							type: "object",
+							properties: {
+								data: {
+									type: "array",
+									items: { $ref: `#/components/schemas/${schemaName}` }
+								},
+								meta: { $ref: "#/components/schemas/PaginationMeta" }
+							}
+						} } }
+					},
+					...errorResponses(requireAuth)
+				}
+			},
+			post: {
+				tags: [collection.name],
+				summary: `Create ${collection.singularName || collection.name}`,
+				operationId: `create${schemaName}`,
+				requestBody: {
+					required: true,
+					content: { "application/json": { schema: { $ref: `#/components/schemas/${schemaName}Input` } } }
+				},
+				responses: {
+					201: {
+						description: "Created entity",
+						content: { "application/json": { schema: { $ref: `#/components/schemas/${schemaName}` } } }
+					},
+					...errorResponses(requireAuth)
+				}
+			}
+		};
+		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. A key names one request: re-send the identical request to replay its answer, and use a new key for a different one."
+		};
+		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. Retry it: the first attempt's result is replayed once it lands",
+				content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } }
+			},
+			422: {
+				description: "The Idempotency-Key was already used for a different request",
+				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: {
+				tags: [collection.name],
+				summary: `Get ${collection.singularName || collection.name} by ID`,
+				operationId: `get${schemaName}ById`,
+				parameters: [{
+					name: "id",
+					in: "path",
+					required: true,
+					schema: { type: "string" },
+					description: "Entity ID"
+				}, {
+					name: "include",
+					in: "query",
+					schema: { type: "string" },
+					description: "Comma-separated list of relations to include",
+					example: "author,tags"
+				}],
+				responses: {
+					200: {
+						description: "Entity found",
+						content: { "application/json": { schema: { $ref: `#/components/schemas/${schemaName}` } } }
+					},
+					404: {
+						description: "Entity not found",
+						content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } }
+					},
+					...errorResponses(requireAuth)
+				}
+			},
+			patch: updateOperation(collection, schemaName, requireAuth),
+			put: {
+				...updateOperation(collection, schemaName, requireAuth),
+				operationId: `update${schemaName}ViaPut`,
+				deprecated: true
+			},
+			delete: {
+				tags: [collection.name],
+				summary: `Delete ${collection.singularName || collection.name}`,
+				operationId: `delete${schemaName}`,
+				parameters: [{
+					name: "id",
+					in: "path",
+					required: true,
+					schema: { type: "string" },
+					description: "Entity ID"
+				}],
+				responses: {
+					204: { description: "Deleted successfully" },
+					404: {
+						description: "Entity not found",
+						content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } }
+					},
+					...errorResponses(requireAuth)
+				}
+			}
+		};
+	}
+	for (const collection of collections || []) {
+		const slug = collection.slug;
+		const schemaName = schemaNameFor(collection);
+		const relations = Object.values(resolveCollectionRelations(collection)).filter(isToMany);
+		for (const relation of relations) {
+			const relationName = relation.relationName;
+			const targetSchema = schemaNameFor(relation.target());
+			const subPath = `/data/${slug}/{parentId}/${relationName}`;
+			paths[subPath] = { get: {
+				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`
+				}, ...listQueryParameters()],
+				responses: {
+					200: {
+						description: `List of related ${relationName}`,
+						content: { "application/json": { schema: {
+							type: "object",
+							properties: {
+								data: {
+									type: "array",
+									items: schemas[targetSchema] ? { $ref: `#/components/schemas/${targetSchema}` } : { type: "object" }
+								},
+								meta: { $ref: "#/components/schemas/PaginationMeta" }
+							}
+						} } }
+					},
+					...errorResponses(requireAuth)
+				}
+			} };
+		}
+	}
+	return spec;
+}
+/**
+* Is this property part of the shape the document may describe?
+*
+* Two exclusions, and both are the document telling the truth about what the
+* server does:
+*
+* - a `relation` property is virtual: the row carries the owning side's foreign
+*   key column, never the property itself, so it is not a field of any payload.
+*   (The FK column *is* readable, writable and filterable and is still absent
+*   from every schema here — a separate gap, not this rule.)
+* - `excludeFromApi` is a server-side guarantee that the column "is stripped
+*   from every row the API serves, for every caller, including admins and
+*   service keys" — `stripExcluded` in the row pipeline enforces it. A schema
+*   that lists such a column describes a field that is never present, and it
+*   describes it to everyone: `/docs` is mounted on the app, not on the data
+*   router, so it carries none of the auth middleware `{basePath}/data` does.
+*   Every project scaffolded by `rebase init` published its `users`
+*   collection's `passwordHash` and `emailVerificationToken` this way.
+*
+* Written as one predicate rather than three `continue`s because it kept being
+* fixed in one loop at a time: this is the same rule the SDK generator applies
+* to its `Row` type (`packages/codegen/src/generate-types.ts`).
+*/
+function isDocumentedProperty(property) {
+	return property.type !== "relation" && !property.excludeFromApi;
+}
+/**
+* Build the component schema for a collection (output / read shape).
+*
+* Every declared property except the ones {@link isDocumentedProperty} rules
+* out.
+*/
+function buildCollectionSchema(collection) {
+	const properties = { id: {
+		type: "string",
+		description: "Unique identifier"
+	} };
+	const required = ["id"];
+	for (const [key, property] of Object.entries(collection.properties)) {
+		if (!isDocumentedProperty(property)) continue;
+		properties[key] = convertPropertyToSchema(property);
+		if (property.validation?.required) required.push(key);
+	}
+	return {
+		type: "object",
+		required: required.length > 0 ? required : void 0,
+		properties
+	};
+}
+/**
+* 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.
+*
+* `excludeFromApi` columns are left out too, though a write naming one is still
+* accepted: a create the document invites and whose result it then cannot show
+* is not a round trip anyone can verify, and naming the column here discloses
+* it just as loudly as the read schema does — this document is served
+* unauthenticated.
+*/
+function buildCollectionInputSchema(collection) {
+	const properties = {};
+	const required = [];
+	for (const [key, property] of Object.entries(collection.properties)) {
+		if (!isDocumentedProperty(property)) continue;
+		if (property.type === "date" && property.autoValue) continue;
+		if ("isId" in property && property.isId && property.isId !== "manual" && property.isId !== true) continue;
+		properties[key] = convertPropertyToSchema(property);
+		if (property.validation?.required) required.push(key);
+	}
+	properties["id"] = {
+		type: "string",
+		description: "Optional: client-assigned ID. If omitted, the server generates one."
+	};
+	return {
+		type: "object",
+		required: required.length > 0 ? required : void 0,
+		properties
+	};
+}
+/**
+* Convert a Rebase Property to an OpenAPI 3.0 schema object.
+*/
+function convertPropertyToSchema(property) {
+	const base = {};
+	if (property.name) base.description = property.name;
+	switch (property.type) {
+		case "string": {
+			const sp = property;
+			base.type = "string";
+			if (sp.enum) {
+				const enumValues = resolveEnumValues(sp.enum);
+				if (enumValues.length > 0) base.enum = enumValues;
+			}
+			if (sp.validation) {
+				if (sp.validation.min !== void 0) base.minLength = sp.validation.min;
+				if (sp.validation.max !== void 0) base.maxLength = sp.validation.max;
+				if (sp.validation.length !== void 0) {
+					base.minLength = sp.validation.length;
+					base.maxLength = sp.validation.length;
+				}
+				if (sp.validation.matches !== void 0) base.pattern = String(sp.validation.matches);
+			}
+			if (sp.email) base.format = "email";
+			if (sp.url) base.format = "uri";
+			if (sp.storage) base.format = "uri";
+			return base;
+		}
+		case "number": {
+			const np = property;
+			base.type = np.validation?.integer || np.columnType === "integer" || np.columnType === "serial" || np.columnType === "bigserial" || np.columnType === "bigint" ? "integer" : "number";
+			if (np.enum) {
+				const enumValues = resolveEnumValues(np.enum);
+				if (enumValues.length > 0) base.enum = enumValues;
+			}
+			if (np.validation) {
+				if (np.validation.min !== void 0) base.minimum = np.validation.min;
+				if (np.validation.max !== void 0) base.maximum = np.validation.max;
+				if (np.validation.moreThan !== void 0) {
+					base.minimum = np.validation.moreThan;
+					base.exclusiveMinimum = true;
+				}
+				if (np.validation.lessThan !== void 0) {
+					base.maximum = np.validation.lessThan;
+					base.exclusiveMaximum = true;
+				}
+			}
+			return base;
+		}
+		case "boolean":
+			base.type = "boolean";
+			return base;
+		case "date":
+			base.type = "string";
+			if (property.mode === "date") base.format = "date";
+			else base.format = "date-time";
+			if (property.autoValue) {
+				base.readOnly = true;
+				base.description = (base.description || "") + (property.autoValue === "on_create" ? " (Auto-set on creation)" : " (Auto-updated)");
+			}
+			return base;
+		case "geopoint":
+			base.type = "object";
+			base.properties = {
+				latitude: { type: "number" },
+				longitude: { type: "number" }
+			};
+			base.required = ["latitude", "longitude"];
+			return base;
+		case "reference":
+			base.type = "string";
+			base.description = (base.description || "") + " (Reference ID)";
+			return base;
+		case "array": {
+			const ap = property;
+			base.type = "array";
+			if (ap.oneOf) {
+				const typeField = ap.oneOf.typeField || "type";
+				const valueField = ap.oneOf.valueField || "value";
+				const variants = [];
+				for (const [variantKey, variantProp] of Object.entries(ap.oneOf.properties)) variants.push({
+					type: "object",
+					properties: {
+						[typeField]: {
+							type: "string",
+							enum: [variantKey]
+						},
+						[valueField]: convertPropertyToSchema(variantProp)
+					},
+					required: [typeField, valueField]
+				});
+				base.items = { oneOf: variants };
+			} else if (ap.of) if (Array.isArray(ap.of)) base.items = { oneOf: ap.of.map((p) => convertPropertyToSchema(p)) };
+			else base.items = convertPropertyToSchema(ap.of);
+			else base.items = {};
+			if (ap.validation) {
+				if (ap.validation.min !== void 0) base.minItems = ap.validation.min;
+				if (ap.validation.max !== void 0) base.maxItems = ap.validation.max;
+			}
+			return base;
+		}
+		case "map": {
+			const mp = property;
+			base.type = "object";
+			if (mp.properties) {
+				const props = {};
+				const req = [];
+				for (const [key, subProp] of Object.entries(mp.properties)) {
+					props[key] = convertPropertyToSchema(subProp);
+					if (subProp.validation?.required) req.push(key);
+				}
+				base.properties = props;
+				if (req.length > 0) base.required = req;
+			} else if (mp.keyValue) base.additionalProperties = true;
+			return base;
+		}
+		case "vector": {
+			const vp = property;
+			base.type = "array";
+			base.items = { type: "number" };
+			base.description = (base.description || "") + ` (Vector(${vp.dimensions}))`;
+			return base;
+		}
+		case "binary":
+			base.type = "string";
+			base.description = (base.description || "") + " (Binary/Base64)";
+			return base;
+		default:
+			base.type = "string";
+			return base;
+	}
+}
+/**
+* Resolve EnumValues (array or record) into a flat array of enum values.
+*/
+function resolveEnumValues(enumDef) {
+	if (Array.isArray(enumDef)) return enumDef.map((e) => typeof e === "object" && e !== null && "id" in e ? e.id : e);
+	return Object.keys(enumDef).map((k) => {
+		const num = Number(k);
+		return isNaN(num) ? k : num;
+	});
+}
+/**
+* Build PostgREST-style filter parameters for a collection.
+* These are additional query parameters like `?status=eq.active&price=gte.100`.
+*
+* `excludeFromApi` columns are not offered: the server does filter on them, and
+* that is exactly the problem — a filter on a column no response can contain
+* answers questions about the value one row at a time, which is a worse
+* disclosure than the column name alone.
+*/
+function buildFilterParameters(collection, reservedNames = /* @__PURE__ */ new Set()) {
+	const params = [];
+	for (const [key, property] of Object.entries(collection.properties)) {
+		if (!isDocumentedProperty(property)) continue;
+		if (property.type === "map" || property.type === "array" || property.type === "geopoint") continue;
+		if (reservedNames.has(key)) continue;
+		params.push({
+			name: key,
+			in: "query",
+			required: false,
+			schema: { type: "string" },
+			description: `Filter by \`${key}\`. Supports PostgREST operators: \`eq.value\`, \`neq.value\`, \`gt.value\`, \`gte.value\`, \`lt.value\`, \`lte.value\`, \`in.(a,b,c)\`, \`nin.(a,b,c)\`, \`cs.value\` (array-contains), \`csa.(a,b)\` (array-contains-any). Plain values imply equality.`,
+			example: property.type === "string" ? "eq.active" : property.type === "number" ? "gte.100" : void 0
+		});
+	}
+	return params;
+}
+/**
+* Standard error responses included on every endpoint.
+*/
+function errorResponses(requireAuth) {
+	const responses = {
+		400: {
+			description: "Bad request",
+			content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } }
+		},
+		500: {
+			description: "Internal server error",
+			content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } }
+		}
+	};
+	if (requireAuth) {
+		responses[401] = {
+			description: "Authentication required or invalid token",
+			content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } }
+		};
+		responses[403] = {
+			description: "Insufficient permissions",
+			content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } }
+		};
+	}
+	return responses;
+}
+/**
+* Prefix a noun with "a" or "an" based on its leading sound.
+*/
+function withIndefiniteArticle(noun) {
+	return `${/^[aeiou]/i.test(noun) ? "an" : "a"} ${noun}`;
+}
+/**
+* The component-schema name for a collection — and the stem of every
+* `operationId` and `$ref` that mentions it.
+*
+* `toPascalCase` keeps ASCII letters and digits and nothing else, so a name
+* written in a script that has none of them — a Cyrillic or Japanese
+* `singularName`, which the docs' six locales make ordinary rather than exotic
+* — reduced to the empty string. The schema was then stored under `""` and
+* every reference to it read `#/components/schemas/`, an unresolvable pointer:
+* Swagger UI renders the model empty and a strict generator fails outright. So
+* fall through the names until one survives, and keep a constant as the floor.
+*
+* Two collections whose names PascalCase identically still share one component;
+* that needs a disambiguation rule, not a fallback.
+*/
+function schemaNameFor(collection) {
+	return toPascalCase(collection.singularName || "") || toPascalCase(collection.name || "") || toPascalCase(collection.slug || "") || "Collection";
+}
+/**
+* Convert a string to PascalCase for schema names.
+*/
+function toPascalCase(str) {
+	return str.replace(/[^a-zA-Z0-9]+/g, " ").split(" ").filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+//#endregion
+export { generateOpenApiSpec };
+
+//# sourceMappingURL=openapi-generator-BQxxxDpb.js.map