@rebasepro/codegen 0.13.0 → 0.13.1-canary.g06dbe5b

package/README.md

@@ -8,10 +8,10 @@ Generates typed TypeScript definitions from Rebase collection definitions — pr
 pnpm add @rebasepro/codegen
 ```
 
-### Peer Dependencies
+### Dependencies
 
-- `@rebasepro/common`
-- `@rebasepro/types`
+- `@rebasepro/common` — a runtime dependency (`resolveCollectionRelations`)
+- `@rebasepro/types` — a peer dependency (types only)
 
 ## What This Package Does
 
@@ -29,20 +29,55 @@ This is typically invoked via the CLI (`npx rebase generate-sdk`) rather than ca
 | `GenerateSDKOptions` | Interface | `{ includeReadme?: boolean }` (default: `true`) |
 | `toPascalCase` | Function | `"my_collection"` → `"MyCollection"` |
 | `toCamelCase` | Function | `"my_collection"` → `"myCollection"` |
-| `toSafeIdentifier` | Function | Converts slugs to valid JS identifiers |
+| `toSafeIdentifier` | Function | Converts a **slug** to a valid JS identifier (collection accessors only — never column names) |
 | `indent` | Function | Indent text by N spaces |
+| `CodegenError` | Class | Thrown for a schema that cannot be expressed as valid TypeScript |
 
 ## Generated Output
 
 `generateSDK()` produces:
 
-1. **`database.types.ts`** — A `Database` interface where each collection slug is a key containing:
-   - `Row` — Full snapshot type (read operations)
-   - `Insert` — Type for creating snapshots (auto-ID fields are optional)
-   - `Update` — All-optional partial type for updates
+1. **`database.types.ts`** — A `Database` interface keyed by each collection's
+   *accessor* (`my-notes` → `myNotes`, the property name on `client.data`),
+   alongside a `collectionsDictionary` const mapping each accessor back to the
+   slug the wire uses. Each entry contains:
+   - `Row` — what a read serves. Column names are the **real** ones, unchanged:
+     a `created_at` column is `row.created_at`. Nullable columns are `T | null`,
+     the primary key is always present, relations appear only when `include`
+     names them, and `excludeFromApi` columns are absent.
+   - `Insert` — what `create()` accepts. Server-assigned ids are optional; a
+     `belongsTo` target may be named either way (`{ author: 5 }` or
+     `{ author_id: 5 }`); `excludeFromApi` columns are absent here too.
+   - `Update` — what `update()` accepts. Everything optional, primary key
+     omitted, `excludeFromApi` columns absent.
+
+`excludeFromApi` means one thing in all three: the API surface does not mention
+the property, in either direction. The server still accepts such a field on a
+write — this is what the generated types describe, not a new enforcement point —
+but nothing generated names it, so a generated client cannot offer a password
+hash as something to read, filter or send.
 
 2. **`README.md`** — Usage instructions (opt out with `includeReadme: false`)
 
+### Names
+
+Only the collection accessor is transformed. Column names are emitted verbatim,
+quoted when they are not valid identifiers (`"user id"?: string | null`), because
+`where` and `orderBy` are keyed off `Row` — a renamed column makes the correct
+filter fail to compile and the wrong one fail at runtime.
+
+Generation **fails** rather than emitting a broken file when two slugs would
+produce the same accessor: the interface would not compile, and
+`collectionsDictionary` would silently keep only one, routing a collection's
+reads to another's table.
+
+### Untrusted schemas
+
+`rebase generate-sdk --from <url>` generates from a remote contract, so slugs,
+column names and enum values come from that server. Every one of them is emitted
+as an escaped literal — untrusted input cannot add a declaration to the generated
+file. There is a test that asserts exactly this.
+
 ### Property Type Mapping
 
 | Rebase Type | TypeScript Type |
@@ -53,8 +88,8 @@ This is typically invoked via the CLI (`npx rebase generate-sdk`) rather than ca
 | `date` | `string` (ISO 8601) |
 | `geopoint` | `{ latitude: number; longitude: number }` |
 | `reference` | `string \| number` |
-| `relation` | Relation object type |
-| `map` | Inline object type or `Record<string, any>` |
+| `relation` | The target's own `Row`, inlined (what `include` serves) |
+| `map` | Inline object type or `Record<string, unknown>` |
 | `array` | `Array<T>` with inferred inner type |
 | `vector` | `number[]` |
 | `binary` | `string` |

package/dist/generate-types.d.ts

@@ -1,2 +1,13 @@
 import { CollectionConfig } from "@rebasepro/types";
-export declare function generateTypedefs(collections: CollectionConfig[]): string;
+/**
+ * A schema that cannot be expressed as a valid TypeScript file.
+ *
+ * Thrown rather than emitted. The generator used to concatenate whatever it was
+ * given, so a slug that collided with another one, or that was not an
+ * identifier, produced a file that either failed to compile or — worse —
+ * compiled while quietly routing one collection to another's slug.
+ */
+export declare class CodegenError extends Error {
+    constructor(message: string);
+}
+export declare function generateTypedefs(input: CollectionConfig[]): string;

package/dist/index.d.ts

@@ -4,7 +4,7 @@
  * Generates a purely typed Typescript database definition.
  */
 import { CollectionConfig } from "@rebasepro/types";
-export { generateTypedefs } from "./generate-types";
+export { generateTypedefs, CodegenError } from "./generate-types";
 export { toPascalCase, toCamelCase, toSafeIdentifier, indent } from "./utils";
 export interface GeneratedFile {
     /** Relative file path within the output directory */

package/dist/index.es.js

@@ -1,4 +1,4 @@
-import { resolveCollectionRelations } from "@rebasepro/common";
+import { findRelation, resolveCollectionRelations, sortCollectionsBySlug } from "@rebasepro/common";
 //#region src/utils.ts
 /**
 * Utility functions for the SDK generator
@@ -43,16 +43,70 @@ function indent(text, spaces) {
 }
 //#endregion
 //#region src/generate-types.ts
+/**
+* A schema that cannot be expressed as a valid TypeScript file.
+*
+* Thrown rather than emitted. The generator used to concatenate whatever it was
+* given, so a slug that collided with another one, or that was not an
+* identifier, produced a file that either failed to compile or — worse —
+* compiled while quietly routing one collection to another's slug.
+*/
+var CodegenError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CodegenError";
+	}
+};
+var IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+/**
+* A property name for the emitted TypeScript: verbatim when it is a valid
+* identifier, quoted otherwise.
+*
+* Every key that reaches the output goes through here. Column names are not
+* required to be identifiers — `"order"`, `"user id"`, a quoted Postgres
+* identifier — and the previous behaviour of camel-casing them into shape
+* renamed the column in the type while the wire kept the original, so the
+* generated `Row` described fields that did not exist.
+*/
+function emitKey(key) {
+	return IDENTIFIER.test(key) ? key : JSON.stringify(key);
+}
+/**
+* A string literal, escaped.
+*
+* `"${value}"` was the previous form. A value containing a quote closed the
+* literal early, which at best broke the file and at worst let a slug from a
+* remote contract inject top-level statements into a file the developer
+* compiles and bundles.
+*/
+function emitString(value) {
+	return JSON.stringify(value);
+}
+/** The `id`s of an enum declared as an array, an array of `{ id }`, or an object map. */
+function enumIds(raw) {
+	if (Array.isArray(raw)) return raw.map((entry) => entry && typeof entry === "object" ? entry.id : entry);
+	if (raw && typeof raw === "object") return Object.keys(raw);
+	return [];
+}
 function propertyToTypeScriptType(prop) {
 	switch (prop.type) {
 		case "string": {
 			const sp = prop;
-			if (sp.enum) return (Array.isArray(sp.enum) ? sp.enum.map((e) => typeof e === "object" ? String(e.id) : String(e)) : Object.keys(sp.enum)).map((v) => `"${v}"`).join(" | ");
+			if (sp.enum) {
+				const ids = enumIds(sp.enum);
+				if (ids.length === 0) return "string";
+				return ids.map((v) => emitString(String(v))).join(" | ");
+			}
 			return "string";
 		}
 		case "number": {
 			const np = prop;
-			if (np.enum) return (Array.isArray(np.enum) ? np.enum.map((e) => typeof e === "object" ? String(e.id) : String(e)) : Object.keys(np.enum)).join(" | ");
+			if (np.enum) {
+				const ids = enumIds(np.enum);
+				const numbers = ids.map(Number);
+				if (ids.length === 0 || numbers.some((n) => !Number.isFinite(n))) return "number";
+				return numbers.map((n) => String(n)).join(" | ");
+			}
 			return "number";
 		}
 		case "boolean": return "boolean";
@@ -62,7 +116,12 @@ function propertyToTypeScriptType(prop) {
 		case "relation": return "string | number";
 		case "map": {
 			const mapProp = prop;
-			if (mapProp.properties) return `{ ${Object.entries(mapProp.properties).map(([k, v]) => `${toSafeIdentifier(k)}: ${propertyToTypeScriptType(v)};`).join(" ")} }`;
+			if (mapProp.properties) return `{ ${Object.entries(mapProp.properties).map(([k, v]) => {
+				const child = v;
+				const optional = !child.validation?.required;
+				const type = propertyToTypeScriptType(child);
+				return `${emitKey(k)}${optional ? "?" : ""}: ${optional ? `${type} | null` : type};`;
+			}).join(" ")} }`;
 			return "Record<string, unknown>";
 		}
 		case "array": {
@@ -96,6 +155,18 @@ function foreignKeyType(relation) {
 	if (!idProp) return "string | number";
 	return idProp[1].type === "number" ? "number" : "string";
 }
+/** Whether a property is the collection's primary key. */
+function isPrimaryKey(prop) {
+	return Boolean(prop.isId);
+}
+/**
+* Whether the server assigns this primary key, so a write does not have to.
+* `true` and `"manual"` both mean the caller supplies it.
+*/
+function isAutoAssignedId(prop) {
+	const isId = prop.isId;
+	return Boolean(isId) && isId !== "manual" && isId !== true;
+}
 /**
 * The type an *included* relation arrives as: the target's own row, inlined.
 *
@@ -108,13 +179,69 @@ function foreignKeyType(relation) {
 * Falls back to an open record when the target is not part of this generation
 * run, since there is no `Row` to point at.
 */
-function includedRelationType(relation, knownSlugs) {
+function includedRelationType(relation, accessors) {
 	const slug = resolveTargetCollection(relation)?.slug ?? relation.targetSlug;
-	const rowType = slug && knownSlugs.has(slug) ? `Database[${JSON.stringify(toSafeIdentifier(slug))}]["Row"]` : "Record<string, unknown>";
+	const accessor = slug ? accessors.get(slug) : void 0;
+	const rowType = accessor ? `Database[${emitString(accessor)}]["Row"]` : "Record<string, unknown>";
 	return relation.cardinality === "many" ? `Array<${rowType}>` : rowType;
 }
-function generateTypedefs(collections) {
-	const knownSlugs = new Set(collections.map((c) => c.slug).filter(Boolean));
+/**
+* Map every slug to the property name it is reachable under on `client.data`.
+*
+* The accessor is a safe identifier because `client.data.myNotes` is the point
+* of generating this at all, and `collectionsDictionary` maps it back to the
+* slug the wire uses. Two slugs that safe down to the same identifier cannot
+* both have it: the interface would not compile, and the dictionary — an object
+* literal — would silently keep only the last, routing one collection's reads
+* to the other's table. There is no defensible way to pick, so this refuses.
+*/
+function buildAccessors(collections) {
+	const accessors = /* @__PURE__ */ new Map();
+	const bySafeName = /* @__PURE__ */ new Map();
+	for (const collection of collections) {
+		const slug = collection.slug;
+		if (typeof slug !== "string" || slug.length === 0) throw new CodegenError("A collection has no slug, so it has no name to generate a type for. Every collection needs a unique `slug`.");
+		const safe = toSafeIdentifier(slug);
+		if (safe.length === 0) throw new CodegenError(`The slug ${emitString(slug)} has no characters that can form a property name, so it cannot be reached as \`client.data.<name>\`. Use a slug containing letters, digits, underscores or dashes.`);
+		const existing = bySafeName.get(safe);
+		if (existing !== void 0) throw new CodegenError(`The collections ${emitString(existing)} and ${emitString(slug)} both generate the accessor "${safe}", so only one of them could be reached from the generated client and the other's reads would silently go to the wrong table. Rename one of the slugs.`);
+		bySafeName.set(safe, slug);
+		accessors.set(slug, safe);
+	}
+	return accessors;
+}
+/** One emitted `key: type;` line, already indented. */
+function line(key, type, optional) {
+	return `      ${emitKey(key)}${optional ? "?" : ""}: ${type};`;
+}
+/**
+* The keys `excludeFromApi` takes off the API surface — in *both* directions.
+*
+* `excludeFromApi` means one thing: the API surface does not mention this
+* property. `Row` already honoured that; `Insert` and `Update` deliberately did
+* not, on the reading that the column is stripped from responses rather than
+* from writes. That left the generated types as the one place a password hash
+* was still named, and it invited a client to send one. The server still
+* *accepts* such a field on a write — this describes the surface, it does not
+* add an enforcement point — but nothing generated advertises it.
+*
+* Keyed by the property name *and* by its column name, the same pair the
+* server's `stripExcluded` deletes, so a foreign key or a relation addressed
+* under the column name cannot put the property back.
+*/
+function excludedApiKeys(properties) {
+	const excluded = /* @__PURE__ */ new Set();
+	for (const [key, rawProp] of Object.entries(properties)) {
+		const prop = rawProp;
+		if (!prop?.excludeFromApi) continue;
+		excluded.add(key);
+		if (prop.columnName) excluded.add(prop.columnName);
+	}
+	return excluded;
+}
+function generateTypedefs(input) {
+	const collections = sortCollectionsBySlug(input);
+	const accessors = buildAccessors(collections);
 	const lines = [
 		"/**",
 		" * This file was auto-generated by Rebase.",
@@ -124,21 +251,27 @@ function generateTypedefs(collections) {
 		"export interface Database {"
 	];
 	for (const collection of collections) {
-		toPascalCase(collection.slug);
 		const properties = collection.properties ?? {};
 		let resolvedRelations = {};
 		try {
 			resolvedRelations = resolveCollectionRelations(collection);
-		} catch {}
-		lines.push(`  ${toSafeIdentifier(collection.slug)}: {`);
+		} catch (e) {
+			console.warn(`[rebase] Could not resolve the relations of "${collection.slug}", so its generated type has no relation fields and none of their foreign-key columns. This is usually a circular import in the collection files — make sure the target is \`() => otherCollection\` and not evaluated at module load.\n  ${e instanceof Error ? e.message : String(e)}`);
+		}
+		const subcollections = collection.subcollections;
+		if (Array.isArray(subcollections) && subcollections.length > 0) console.warn(`[rebase] "${collection.slug}" declares ${subcollections.length} subcollection(s), which are not part of the generated Database: they are reached over a nested path (\`data/${collection.slug}/<id>/<relation>\`), not as a top-level accessor. Register a subcollection as a collection of its own if you want a typed accessor for it.`);
+		lines.push(`  ${emitKey(accessors.get(collection.slug))}: {`);
 		lines.push("    Row: {");
 		const emittedKeys = /* @__PURE__ */ new Set();
+		const excluded = excludedApiKeys(properties);
+		for (const key of excluded) emittedKeys.add(key);
 		for (const [key, rawProp] of Object.entries(properties)) {
 			const prop = rawProp;
 			if (prop.type === "relation") continue;
+			if (excluded.has(key)) continue;
 			const tsType = propertyToTypeScriptType(prop);
-			const isRequired = prop.validation?.required;
-			lines.push(`      ${toSafeIdentifier(key)}${isRequired ? "" : "?"}: ${tsType};`);
+			const isRequired = Boolean(prop.validation?.required) || isPrimaryKey(prop);
+			lines.push(line(key, isRequired ? tsType : `${tsType} | null`, !isRequired));
 			emittedKeys.add(key);
 		}
 		for (const [relKey, relation] of Object.entries(resolvedRelations)) if (relation.kind === "belongsTo" && relation.localKey) {
@@ -146,74 +279,94 @@ function generateTypedefs(collections) {
 			if (emittedKeys.has(fkKey)) continue;
 			const fkType = foreignKeyType(relation);
 			const shadowedByInclude = relKey === fkKey;
-			const tsType = shadowedByInclude ? `${fkType} | ${includedRelationType(relation, knownSlugs)}` : fkType;
-			const isRequired = relation.validation?.required && !shadowedByInclude;
-			lines.push(`      ${toSafeIdentifier(fkKey)}${isRequired ? "" : "?"}: ${tsType};`);
+			const tsType = shadowedByInclude ? `${fkType} | ${includedRelationType(relation, accessors)}` : fkType;
+			const isRequired = Boolean(relation.validation?.required) && !shadowedByInclude;
+			lines.push(line(fkKey, isRequired ? tsType : `${tsType} | null`, !isRequired));
 			emittedKeys.add(fkKey);
 		}
 		for (const [key, relation] of Object.entries(resolvedRelations)) {
 			if (emittedKeys.has(key)) continue;
-			lines.push(`      ${toSafeIdentifier(key)}?: ${includedRelationType(relation, knownSlugs)};`);
+			lines.push(line(key, includedRelationType(relation, accessors), true));
 			emittedKeys.add(key);
 		}
 		for (const [key, rawProp] of Object.entries(properties)) {
 			if (rawProp.type !== "relation") continue;
 			if (emittedKeys.has(key)) continue;
-			lines.push(`      ${toSafeIdentifier(key)}?: Record<string, unknown>;`);
+			lines.push(line(key, "Record<string, unknown>", true));
 			emittedKeys.add(key);
 		}
 		lines.push("    };");
 		lines.push("    Insert: {");
 		emittedKeys.clear();
+		for (const key of excluded) emittedKeys.add(key);
 		for (const [key, rawProp] of Object.entries(properties)) {
 			const prop = rawProp;
 			if (prop.type === "relation") continue;
+			if (excluded.has(key)) continue;
 			const tsType = propertyToTypeScriptType(prop);
-			const isRequired = prop.validation?.required;
-			const typedProp = prop;
-			const isAutoId = "isId" in prop && typedProp.isId && typedProp.isId !== "manual" && typedProp.isId !== true;
-			const isOptional = !isRequired || isAutoId;
-			lines.push(`      ${toSafeIdentifier(key)}${isOptional ? "?" : ""}: ${tsType};`);
+			const isOptional = !prop.validation?.required || isAutoAssignedId(prop);
+			lines.push(line(key, tsType, isOptional));
 			emittedKeys.add(key);
 		}
-		for (const [relKey, relation] of Object.entries(resolvedRelations)) if (relation.kind === "belongsTo" && relation.localKey) {
-			const fkKey = relation.localKey;
-			if (emittedKeys.has(fkKey)) continue;
-			const fkType = "string | number";
-			const isRequired = relation.validation?.required;
-			lines.push(`      ${toSafeIdentifier(fkKey)}${isRequired ? "" : "?"}: ${fkType};`);
-			emittedKeys.add(fkKey);
-		}
+		emitWritableRelations(lines, properties, resolvedRelations, emittedKeys, false);
 		lines.push("    };");
 		lines.push("    Update: {");
 		emittedKeys.clear();
+		for (const key of excluded) emittedKeys.add(key);
 		for (const [key, rawProp] of Object.entries(properties)) {
 			const prop = rawProp;
 			if (prop.type === "relation") continue;
-			const tsType = propertyToTypeScriptType(prop);
-			lines.push(`      ${toSafeIdentifier(key)}?: ${tsType};`);
+			if (isPrimaryKey(prop)) continue;
+			if (excluded.has(key)) continue;
+			lines.push(line(key, propertyToTypeScriptType(prop), true));
 			emittedKeys.add(key);
 		}
-		for (const [relKey, relation] of Object.entries(resolvedRelations)) if (relation.kind === "belongsTo" && relation.localKey) {
-			const fkKey = relation.localKey;
-			if (emittedKeys.has(fkKey)) continue;
-			lines.push(`      ${toSafeIdentifier(fkKey)}?: string | number;`);
-			emittedKeys.add(fkKey);
-		}
+		emitWritableRelations(lines, properties, resolvedRelations, emittedKeys, true);
 		lines.push("    };");
 		lines.push("  };");
 	}
 	lines.push("}");
 	lines.push("");
 	lines.push("export type CollectionName = keyof Database;");
-	lines.push("export type CollectionsDictionary = { [K in CollectionName]: K };");
 	lines.push("");
 	lines.push("export const collectionsDictionary = {");
-	for (const collection of collections) lines.push(`  ${toSafeIdentifier(collection.slug)}: "${collection.slug}",`);
+	for (const collection of collections) lines.push(`  ${emitKey(accessors.get(collection.slug))}: ${emitString(collection.slug)},`);
 	lines.push("} as const;");
 	lines.push("");
+	lines.push("export type CollectionsDictionary = typeof collectionsDictionary;");
+	lines.push("");
 	return lines.join("\n");
 }
+/**
+* The two ways a write can name a `belongsTo` target, both of which the server
+* accepts: the foreign-key column itself (`{ author_id: 5 }`, which passes
+* through untouched) and the relation *property* (`{ author: 5 }`, which the
+* write transformer maps onto that column).
+*
+* Only the first was generated, so the documented and idiomatic write shape was
+* a type error.
+*
+* The second form is emitted under the **property key**, not the resolved
+* relation name, because that is what the transformer keys off: it looks the
+* payload key up in `properties` and only treats it as a relation if what it
+* finds there is one. A relation whose `relationName` differs from its property
+* key is reachable as the property and not as the name, so emitting the name
+* would have offered a key that writes to a column that does not exist.
+*/
+function emitWritableRelations(lines, properties, resolvedRelations, emittedKeys, allOptional) {
+	const emit = (key, relation) => {
+		if (emittedKeys.has(key)) return;
+		const optional = allOptional || !relation.validation?.required;
+		lines.push(line(key, foreignKeyType(relation), optional));
+		emittedKeys.add(key);
+	};
+	for (const relation of Object.values(resolvedRelations)) if (relation.kind === "belongsTo" && relation.localKey) emit(relation.localKey, relation);
+	for (const [key, rawProp] of Object.entries(properties)) {
+		if (rawProp.type !== "relation") continue;
+		const relation = findRelation(resolvedRelations, key);
+		if (relation?.kind === "belongsTo" && relation.localKey) emit(key, relation);
+	}
+}
 //#endregion
 //#region src/index.ts
 function generateSDK(collections, options = {}) {
@@ -238,25 +391,51 @@ function generateSDK(collections, options = {}) {
 2. Initialize with your generated types:
    \`\`\`typescript
     import { createRebaseClient } from '@rebasepro/client';
-    import { Database, collectionsDictionary } from './database.types';
+    import { collectionsDictionary, type Database } from './database.types';
 
     const rebase = createRebaseClient<Database>({
         baseUrl: 'http://localhost:3001',
+        // Maps each accessor back to the slug the wire uses. Without it a
+        // hyphenated slug is not resolvable from the property name alone.
         collections: collectionsDictionary,
     });
 
-   // Both syntax styles are fully typed!
+   // Property access is the typed surface: rows, filters and sorts are all
+   // checked against the generated Database.
    const { data: users } = await rebase.data.users.find();
    console.log(users[0].email); // flat access — no .values wrapper
-
-   const { data: posts } = await rebase.data.collection('posts').find();
-   console.log(posts[0].title); // just post.title, not post.values.title
    \`\`\`
+
+## Field names are the ones the API serves
+
+The generated \`Row\` uses each column's real name, unchanged — a \`created_at\`
+column is \`row.created_at\`, not \`row.createdAt\`. \`where\` and \`orderBy\` are keyed
+off the same type, so what compiles is what the backend answers to.
+
+Only the *collection accessor* is turned into a property name
+(\`my-notes\` → \`rebase.data.myNotes\`), which is what \`collectionsDictionary\` maps
+back.
+
+## \`Row\` vs \`Insert\` vs \`Update\`
+
+| Type | What it describes |
+|---|---|
+| \`Row\` | What a read serves. Nullable columns are \`T \\| null\`; relations appear only when \`include\` names them. |
+| \`Insert\` | What \`create()\` accepts. Server-assigned ids are optional; a \`belongsTo\` target may be named either way (\`{ author: 5 }\` or \`{ author_id: 5 }\`). |
+| \`Update\` | What \`update()\` accepts. Everything optional, and the primary key is not settable. |
+
+A property marked \`excludeFromApi\` is absent from all three: the API surface
+does not mention it, in either direction. The server still accepts one on a
+write — these types describe the surface, they do not enforce it — but nothing
+generated names a password hash.
+
+If you need an untyped escape hatch, \`rebase.data.collection(slug)\` still works —
+but it is generic over \`Record<string, unknown>\` and gives up everything above.
 `
 	});
 	return files;
 }
 //#endregion
-export { generateSDK, generateTypedefs, indent, toCamelCase, toPascalCase, toSafeIdentifier };
+export { CodegenError, generateSDK, generateTypedefs, indent, toCamelCase, toPascalCase, toSafeIdentifier };
 
 //# sourceMappingURL=index.es.js.map

package/dist/index.es.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es.js","names":[],"sources":["../src/utils.ts","../src/generate-types.ts","../src/index.ts"],"sourcesContent":["/**\n * Utility functions for the SDK generator\n */\n\n/**\n * Convert a slug/snake_case string to PascalCase\n * e.g. \"private_notes\" → \"PrivateNotes\"\n *\n * Capitals already inside a word are meaningful and are kept: lowercasing the\n * tail of every chunk turned \"TestEntities\" into \"Testentities\", which is what\n * ended up in the generated type names. SHOUTING_CASE is the one shape where\n * the tail is not meaningful, so it is folded down.\n */\nexport function toPascalCase(str: string): string {\n    return str\n        .split(/[_\\-\\s]+/)\n        .filter(Boolean)\n        .map(word => {\n            const rest = /^[A-Z0-9]+$/.test(word) ? word.slice(1).toLowerCase() : word.slice(1);\n            return word.charAt(0).toUpperCase() + rest;\n        })\n        .join(\"\");\n}\n\n/**\n * Convert a slug/snake_case string to camelCase\n * e.g. \"private_notes\" → \"privateNotes\"\n */\nexport function toCamelCase(str: string): string {\n    if (!/[_\\-\\s]/.test(str)) {\n        return str.charAt(0).toLowerCase() + str.slice(1);\n    }\n    const pascal = toPascalCase(str);\n    return pascal.charAt(0).toLowerCase() + pascal.slice(1);\n}\n\n/**\n * Convert a slug to a safe JS identifier\n * e.g. \"private-notes\" → \"privateNotes\"\n */\nexport function toSafeIdentifier(str: string): string {\n    return toCamelCase(str.replace(/[^a-zA-Z0-9_]/g, \"_\"));\n}\n\n/**\n * Indent a block of text by a given number of spaces\n */\nexport function indent(text: string, spaces: number): string {\n    const pad = \" \".repeat(spaces);\n    return text\n        .split(\"\\n\")\n        .map(line => (line.trim() ? pad + line : line))\n        .join(\"\\n\");\n}\n","import { CollectionConfig, PostgresCollectionConfig, Property, Properties, MapProperty, ArrayProperty, Relation, RelationProperty, StringProperty, NumberProperty, ResolvedRelation } from \"@rebasepro/types\";\nimport { resolveCollectionRelations } from \"@rebasepro/common\";\nimport { toPascalCase, toSafeIdentifier } from \"./utils\";\n\nfunction propertyToTypeScriptType(prop: Property): string {\n    switch (prop.type) {\n        case \"string\": {\n            const sp = prop as StringProperty;\n            if (sp.enum) {\n                const ids = Array.isArray(sp.enum)\n                    ? sp.enum.map((e: string | number | { id: string | number }) => typeof e === \"object\" ? String(e.id) : String(e))\n                    : Object.keys(sp.enum);\n                return ids.map(v => `\"${v}\"`).join(\" | \");\n            }\n            return \"string\";\n        }\n        case \"number\": {\n            const np = prop as NumberProperty;\n            if (np.enum) {\n                const ids = Array.isArray(np.enum)\n                    ? np.enum.map((e: string | number | { id: string | number }) => typeof e === \"object\" ? String(e.id) : String(e))\n                    : Object.keys(np.enum);\n                return ids.join(\" | \");\n            }\n            return \"number\";\n        }\n        case \"boolean\":\n            return \"boolean\";\n        case \"date\":\n            return \"string\"; // ISO 8601 string over the wire\n        case \"geopoint\":\n            return \"{ latitude: number; longitude: number; }\";\n        case \"reference\":\n            return \"string | number\";\n        case \"relation\":\n            return \"string | number\";\n        case \"map\": {\n            const mapProp = prop as MapProperty;\n            if (mapProp.properties) {\n                const inner = Object.entries(mapProp.properties)\n                    .map(([k, v]) => `${toSafeIdentifier(k)}: ${propertyToTypeScriptType(v as Property)};`)\n                    .join(\" \");\n                return `{ ${inner} }`;\n            }\n            return \"Record<string, unknown>\";\n        }\n        case \"array\": {\n            const arrProp = prop as ArrayProperty;\n            if (arrProp.of) {\n                return `Array<${propertyToTypeScriptType(arrProp.of as Property)}>`;\n            }\n            return \"Array<unknown>\";\n        }\n        case \"vector\":\n            return \"number[]\";\n        case \"binary\":\n            return \"string\";\n        default:\n            return \"unknown\";\n    }\n}\n\n/**\n * Unwrap a relation target that arrived as a module namespace rather than the\n * collection itself — `target: () => import(\"./authors\")` is a common slip.\n */\nfunction resolveTargetCollection(relation: ResolvedRelation): CollectionConfig | undefined {\n    try {\n        let target = relation.target() as CollectionConfig & { default?: CollectionConfig; __esModule?: boolean };\n        if (target && (target.default || target.__esModule)) {\n            target = (target.default ?? target) as typeof target;\n        }\n        return target;\n    } catch {\n        return undefined;\n    }\n}\n\n/** The TypeScript type of a foreign key: whatever the target's primary key is. */\nfunction foreignKeyType(relation: ResolvedRelation): string {\n    const target = resolveTargetCollection(relation);\n    if (!target?.properties) return \"string | number\";\n    const idProp = Object.entries(target.properties).find(([_, p]) => (p as Record<string, unknown>).isId);\n    if (!idProp) return \"string | number\";\n    return (idProp[1] as Property).type === \"number\" ? \"number\" : \"string\";\n}\n\n/**\n * The type an *included* relation arrives as: the target's own row, inlined.\n *\n * This is what the read pipeline actually serves — `toRestRow` puts the\n * target's flat columns where the relation was, and the SDK and the HTTP API\n * both go through it. It is deliberately *not* a `{ __type: \"relation\" }`\n * envelope: that shape is the admin's view-model and never reaches a\n * developer's `find()`.\n *\n * Falls back to an open record when the target is not part of this generation\n * run, since there is no `Row` to point at.\n */\nfunction includedRelationType(relation: ResolvedRelation, knownSlugs: Set<string>): string {\n    const target = resolveTargetCollection(relation);\n    const slug = target?.slug ?? relation.targetSlug;\n    const rowType = slug && knownSlugs.has(slug)\n        ? `Database[${JSON.stringify(toSafeIdentifier(slug))}][\"Row\"]`\n        : \"Record<string, unknown>\";\n    return relation.cardinality === \"many\" ? `Array<${rowType}>` : rowType;\n}\n\nexport function generateTypedefs(collections: CollectionConfig[]): string {\n    const knownSlugs = new Set(collections.map(c => c.slug).filter(Boolean) as string[]);\n    const lines: string[] = [\n        \"/**\",\n        \" * This file was auto-generated by Rebase.\",\n        \" * Do not make direct changes to the file.\",\n        \" */\",\n        \"\",\n        \"export interface Database {\"\n    ];\n\n    for (const collection of collections) {\n        const typeName = toPascalCase(collection.slug);\n        const properties = (collection.properties ?? {}) as Properties;\n\n        // Resolve relations\n        let resolvedRelations: Record<string, ResolvedRelation> = {};\n        try {\n            resolvedRelations = resolveCollectionRelations(collection);\n        } catch { /* ignore */ }\n\n        lines.push(`  ${toSafeIdentifier(collection.slug)}: {`);\n\n        // ── Row Type ──\n        lines.push(\"    Row: {\");\n        const emittedKeys = new Set<string>();\n\n        // 1. Direct properties\n        for (const [key, rawProp] of Object.entries(properties)) {\n            const prop = rawProp as Property;\n            if (prop.type === \"relation\") continue;\n\n            const tsType = propertyToTypeScriptType(prop);\n            const isRequired = prop.validation?.required;\n            lines.push(`      ${toSafeIdentifier(key)}${isRequired ? \"\" : \"?\"}: ${tsType};`);\n            emittedKeys.add(key);\n        }\n\n        // 2. FK columns from relations\n        for (const [relKey, relation] of Object.entries(resolvedRelations)) {\n            if (relation.kind === \"belongsTo\" && relation.localKey) {\n                const fkKey = relation.localKey;\n                if (emittedKeys.has(fkKey)) continue;\n\n                const fkType = foreignKeyType(relation);\n\n                // A relation addressed by the same name as its own foreign key\n                // is served *over* that column when the read includes it: the\n                // query nests the target under the relation name, and the\n                // scalar it shadows is gone. Both outcomes are real, so the\n                // column is typed as both — which is what stops a plain\n                // `const id: string = row.author_id` from compiling.\n                const shadowedByInclude = relKey === fkKey;\n                const tsType = shadowedByInclude\n                    ? `${fkType} | ${includedRelationType(relation, knownSlugs)}`\n                    : fkType;\n\n                const isRequired = relation.validation?.required && !shadowedByInclude;\n                lines.push(`      ${toSafeIdentifier(fkKey)}${isRequired ? \"\" : \"?\"}: ${tsType};`);\n                emittedKeys.add(fkKey);\n            }\n        }\n\n        // 3. Relation fields — the target's own row, inlined.\n        //\n        // Optional throughout: a relation is only loaded when the read names it\n        // in `include`, so it is absent from every other read.\n        for (const [key, relation] of Object.entries(resolvedRelations)) {\n            if (emittedKeys.has(key)) continue;\n            lines.push(`      ${toSafeIdentifier(key)}?: ${includedRelationType(relation, knownSlugs)};`);\n            emittedKeys.add(key);\n        }\n\n        // A `relation` property whose relation could not be resolved — an\n        // engine without relation support, or a target that did not load. It is\n        // still a column on the row, so it is still typed, just not precisely.\n        for (const [key, rawProp] of Object.entries(properties)) {\n            if ((rawProp as Property).type !== \"relation\") continue;\n            if (emittedKeys.has(key)) continue;\n            lines.push(`      ${toSafeIdentifier(key)}?: Record<string, unknown>;`);\n            emittedKeys.add(key);\n        }\n        lines.push(\"    };\");\n\n        // ── Insert Type ──\n        lines.push(\"    Insert: {\");\n        emittedKeys.clear();\n\n        for (const [key, rawProp] of Object.entries(properties)) {\n            const prop = rawProp as Property;\n            if (prop.type === \"relation\") continue;\n            const tsType = propertyToTypeScriptType(prop);\n            const isRequired = prop.validation?.required;\n            const typedProp = prop as StringProperty | NumberProperty;\n            const isAutoId = \"isId\" in prop && typedProp.isId && typedProp.isId !== \"manual\" && typedProp.isId !== true;\n            const isOptional = !isRequired || isAutoId;\n            lines.push(`      ${toSafeIdentifier(key)}${isOptional ? \"?\" : \"\"}: ${tsType};`);\n            emittedKeys.add(key);\n        }\n\n        for (const [relKey, relation] of Object.entries(resolvedRelations)) {\n            if (relation.kind === \"belongsTo\" && relation.localKey) {\n                const fkKey = relation.localKey;\n                if (emittedKeys.has(fkKey)) continue;\n                const fkType = \"string | number\";\n                // simple fallback\n                const isRequired = relation.validation?.required;\n                lines.push(`      ${toSafeIdentifier(fkKey)}${isRequired ? \"\" : \"?\"}: ${fkType};`);\n                emittedKeys.add(fkKey);\n            }\n        }\n        lines.push(\"    };\");\n\n        // ── Update Type ──\n        lines.push(\"    Update: {\");\n        emittedKeys.clear();\n        for (const [key, rawProp] of Object.entries(properties)) {\n            const prop = rawProp as Property;\n            if (prop.type === \"relation\") continue;\n            const tsType = propertyToTypeScriptType(prop);\n            lines.push(`      ${toSafeIdentifier(key)}?: ${tsType};`);\n            emittedKeys.add(key);\n        }\n        for (const [relKey, relation] of Object.entries(resolvedRelations)) {\n            if (relation.kind === \"belongsTo\" && relation.localKey) {\n                const fkKey = relation.localKey;\n                if (emittedKeys.has(fkKey)) continue;\n                lines.push(`      ${toSafeIdentifier(fkKey)}?: string | number;`);\n                emittedKeys.add(fkKey);\n            }\n        }\n        lines.push(\"    };\");\n\n        lines.push(\"  };\");\n    }\n\n    lines.push(\"}\");\n    lines.push(\"\");\n    lines.push(\"export type CollectionName = keyof Database;\");\n    lines.push(\"export type CollectionsDictionary = { [K in CollectionName]: K };\");\n    lines.push(\"\");\n    lines.push(\"export const collectionsDictionary = {\");\n    for (const collection of collections) {\n        lines.push(`  ${toSafeIdentifier(collection.slug)}: \"${collection.slug}\",`);\n    }\n    lines.push(\"} as const;\");\n    lines.push(\"\");\n\n    return lines.join(\"\\n\");\n}\n","/**\n * @rebasepro/codegen\n *\n * Generates a purely typed Typescript database definition.\n */\n\nimport { CollectionConfig } from \"@rebasepro/types\";\nimport { generateTypedefs } from \"./generate-types\";\n\nexport { generateTypedefs } from \"./generate-types\";\nexport { toPascalCase, toCamelCase, toSafeIdentifier, indent } from \"./utils\";\n\n// ─── Public API ────────────────────────────────────────────────────\n\nexport interface GeneratedFile {\n    /** Relative file path within the output directory */\n    path: string;\n    /** File content */\n    content: string;\n}\n\nexport interface GenerateSDKOptions {\n    /** Whether to include a README file (default: true) */\n    includeReadme?: boolean;\n}\n\nexport function generateSDK(\n    collections: CollectionConfig[],\n    options: GenerateSDKOptions = {}\n): GeneratedFile[] {\n    const files: GeneratedFile[] = [];\n\n    files.push({\n        path: \"database.types.ts\",\n        content: generateTypedefs(collections)\n    });\n\n    if (options.includeReadme !== false) {\n        files.push({\n            path: \"README.md\",\n            content: `# Rebase SDK\n\n> Auto-generated by \\`rebase generate-sdk\\`. Do not edit manually.\n\n## Usage\n\n1. Install the client package:\n   \\`\\`\\`bash\n   npm install @rebasepro/client\n   \\`\\`\\`\n\n2. Initialize with your generated types:\n   \\`\\`\\`typescript\n    import { createRebaseClient } from '@rebasepro/client';\n    import { Database, collectionsDictionary } from './database.types';\n\n    const rebase = createRebaseClient<Database>({\n        baseUrl: 'http://localhost:3001',\n        collections: collectionsDictionary,\n    });\n\n   // Both syntax styles are fully typed!\n   const { data: users } = await rebase.data.users.find();\n   console.log(users[0].email); // flat access — no .values wrapper\n\n   const { data: posts } = await rebase.data.collection('posts').find();\n   console.log(posts[0].title); // just post.title, not post.values.title\n   \\`\\`\\`\n`\n        });\n    }\n\n    return files;\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.es.js","names":[],"sources":["../src/utils.ts","../src/generate-types.ts","../src/index.ts"],"sourcesContent":["/**\n * Utility functions for the SDK generator\n */\n\n/**\n * Convert a slug/snake_case string to PascalCase\n * e.g. \"private_notes\" → \"PrivateNotes\"\n *\n * Capitals already inside a word are meaningful and are kept: lowercasing the\n * tail of every chunk turned \"TestEntities\" into \"Testentities\", which is what\n * ended up in the generated type names. SHOUTING_CASE is the one shape where\n * the tail is not meaningful, so it is folded down.\n */\nexport function toPascalCase(str: string): string {\n    return str\n        .split(/[_\\-\\s]+/)\n        .filter(Boolean)\n        .map(word => {\n            const rest = /^[A-Z0-9]+$/.test(word) ? word.slice(1).toLowerCase() : word.slice(1);\n            return word.charAt(0).toUpperCase() + rest;\n        })\n        .join(\"\");\n}\n\n/**\n * Convert a slug/snake_case string to camelCase\n * e.g. \"private_notes\" → \"privateNotes\"\n */\nexport function toCamelCase(str: string): string {\n    if (!/[_\\-\\s]/.test(str)) {\n        return str.charAt(0).toLowerCase() + str.slice(1);\n    }\n    const pascal = toPascalCase(str);\n    return pascal.charAt(0).toLowerCase() + pascal.slice(1);\n}\n\n/**\n * Convert a slug to a safe JS identifier\n * e.g. \"private-notes\" → \"privateNotes\"\n */\nexport function toSafeIdentifier(str: string): string {\n    return toCamelCase(str.replace(/[^a-zA-Z0-9_]/g, \"_\"));\n}\n\n/**\n * Indent a block of text by a given number of spaces\n */\nexport function indent(text: string, spaces: number): string {\n    const pad = \" \".repeat(spaces);\n    return text\n        .split(\"\\n\")\n        .map(line => (line.trim() ? pad + line : line))\n        .join(\"\\n\");\n}\n","import { CollectionConfig, Property, Properties, MapProperty, ArrayProperty, StringProperty, NumberProperty, ResolvedRelation } from \"@rebasepro/types\";\nimport { findRelation, resolveCollectionRelations, sortCollectionsBySlug } from \"@rebasepro/common\";\nimport { toSafeIdentifier } from \"./utils\";\n\n/**\n * A schema that cannot be expressed as a valid TypeScript file.\n *\n * Thrown rather than emitted. The generator used to concatenate whatever it was\n * given, so a slug that collided with another one, or that was not an\n * identifier, produced a file that either failed to compile or — worse —\n * compiled while quietly routing one collection to another's slug.\n */\nexport class CodegenError extends Error {\n    constructor(message: string) {\n        super(message);\n        this.name = \"CodegenError\";\n    }\n}\n\nconst IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;\n\n/**\n * A property name for the emitted TypeScript: verbatim when it is a valid\n * identifier, quoted otherwise.\n *\n * Every key that reaches the output goes through here. Column names are not\n * required to be identifiers — `\"order\"`, `\"user id\"`, a quoted Postgres\n * identifier — and the previous behaviour of camel-casing them into shape\n * renamed the column in the type while the wire kept the original, so the\n * generated `Row` described fields that did not exist.\n */\nfunction emitKey(key: string): string {\n    return IDENTIFIER.test(key) ? key : JSON.stringify(key);\n}\n\n/**\n * A string literal, escaped.\n *\n * `\"${value}\"` was the previous form. A value containing a quote closed the\n * literal early, which at best broke the file and at worst let a slug from a\n * remote contract inject top-level statements into a file the developer\n * compiles and bundles.\n */\nfunction emitString(value: string): string {\n    return JSON.stringify(value);\n}\n\n/** The `id`s of an enum declared as an array, an array of `{ id }`, or an object map. */\nfunction enumIds(raw: unknown): (string | number)[] {\n    if (Array.isArray(raw)) {\n        return raw.map((entry: string | number | { id: string | number }) =>\n            entry && typeof entry === \"object\" ? entry.id : entry);\n    }\n    if (raw && typeof raw === \"object\") return Object.keys(raw);\n    return [];\n}\n\nfunction propertyToTypeScriptType(prop: Property): string {\n    switch (prop.type) {\n        case \"string\": {\n            const sp = prop as StringProperty;\n            if (sp.enum) {\n                const ids = enumIds(sp.enum);\n                if (ids.length === 0) return \"string\";\n                return ids.map(v => emitString(String(v))).join(\" | \");\n            }\n            return \"string\";\n        }\n        case \"number\": {\n            const np = prop as NumberProperty;\n            if (np.enum) {\n                const ids = enumIds(np.enum);\n                const numbers = ids.map(Number);\n                // A numeric enum carrying something that is not a number cannot\n                // be written as a union of numeric literals. Widening to\n                // `number` is imprecise; emitting `NaN | undefined` is invalid.\n                if (ids.length === 0 || numbers.some(n => !Number.isFinite(n))) return \"number\";\n                return numbers.map(n => String(n)).join(\" | \");\n            }\n            return \"number\";\n        }\n        case \"boolean\":\n            return \"boolean\";\n        case \"date\":\n            return \"string\"; // ISO 8601 string over the wire\n        case \"geopoint\":\n            return \"{ latitude: number; longitude: number; }\";\n        case \"reference\":\n            return \"string | number\";\n        case \"relation\":\n            return \"string | number\";\n        case \"map\": {\n            const mapProp = prop as MapProperty;\n            if (mapProp.properties) {\n                const inner = Object.entries(mapProp.properties)\n                    .map(([k, v]) => {\n                        const child = v as Property;\n                        // Nested fields carry validation like any other. Emitting\n                        // them all required claimed a shape the payload does not\n                        // have to satisfy.\n                        const optional = !child.validation?.required;\n                        const type = propertyToTypeScriptType(child);\n                        return `${emitKey(k)}${optional ? \"?\" : \"\"}: ${optional ? `${type} | null` : type};`;\n                    })\n                    .join(\" \");\n                return `{ ${inner} }`;\n            }\n            return \"Record<string, unknown>\";\n        }\n        case \"array\": {\n            const arrProp = prop as ArrayProperty;\n            if (arrProp.of) {\n                return `Array<${propertyToTypeScriptType(arrProp.of as Property)}>`;\n            }\n            return \"Array<unknown>\";\n        }\n        case \"vector\":\n            return \"number[]\";\n        case \"binary\":\n            return \"string\";\n        default:\n            return \"unknown\";\n    }\n}\n\n/**\n * Unwrap a relation target that arrived as a module namespace rather than the\n * collection itself — `target: () => import(\"./authors\")` is a common slip.\n */\nfunction resolveTargetCollection(relation: ResolvedRelation): CollectionConfig | undefined {\n    try {\n        let target = relation.target() as CollectionConfig & { default?: CollectionConfig; __esModule?: boolean };\n        if (target && (target.default || target.__esModule)) {\n            target = (target.default ?? target) as typeof target;\n        }\n        return target;\n    } catch {\n        return undefined;\n    }\n}\n\n/** The TypeScript type of a foreign key: whatever the target's primary key is. */\nfunction foreignKeyType(relation: ResolvedRelation): string {\n    const target = resolveTargetCollection(relation);\n    if (!target?.properties) return \"string | number\";\n    const idProp = Object.entries(target.properties).find(([_, p]) => (p as Record<string, unknown>).isId);\n    if (!idProp) return \"string | number\";\n    return (idProp[1] as Property).type === \"number\" ? \"number\" : \"string\";\n}\n\n/** Whether a property is the collection's primary key. */\nfunction isPrimaryKey(prop: Property): boolean {\n    return Boolean((prop as unknown as Record<string, unknown>).isId);\n}\n\n/**\n * Whether the server assigns this primary key, so a write does not have to.\n * `true` and `\"manual\"` both mean the caller supplies it.\n */\nfunction isAutoAssignedId(prop: Property): boolean {\n    const isId = (prop as unknown as Record<string, unknown>).isId;\n    return Boolean(isId) && isId !== \"manual\" && isId !== true;\n}\n\n/**\n * The type an *included* relation arrives as: the target's own row, inlined.\n *\n * This is what the read pipeline actually serves — `toRestRow` puts the\n * target's flat columns where the relation was, and the SDK and the HTTP API\n * both go through it. It is deliberately *not* a `{ __type: \"relation\" }`\n * envelope: that shape is the admin's view-model and never reaches a\n * developer's `find()`.\n *\n * Falls back to an open record when the target is not part of this generation\n * run, since there is no `Row` to point at.\n */\nfunction includedRelationType(\n    relation: ResolvedRelation,\n    accessors: Map<string, string>\n): string {\n    const target = resolveTargetCollection(relation);\n    const slug = target?.slug ?? relation.targetSlug;\n    const accessor = slug ? accessors.get(slug) : undefined;\n    const rowType = accessor\n        ? `Database[${emitString(accessor)}][\"Row\"]`\n        : \"Record<string, unknown>\";\n    return relation.cardinality === \"many\" ? `Array<${rowType}>` : rowType;\n}\n\n/**\n * Map every slug to the property name it is reachable under on `client.data`.\n *\n * The accessor is a safe identifier because `client.data.myNotes` is the point\n * of generating this at all, and `collectionsDictionary` maps it back to the\n * slug the wire uses. Two slugs that safe down to the same identifier cannot\n * both have it: the interface would not compile, and the dictionary — an object\n * literal — would silently keep only the last, routing one collection's reads\n * to the other's table. There is no defensible way to pick, so this refuses.\n */\nfunction buildAccessors(collections: CollectionConfig[]): Map<string, string> {\n    const accessors = new Map<string, string>();\n    const bySafeName = new Map<string, string>();\n\n    for (const collection of collections) {\n        const slug = collection.slug;\n        if (typeof slug !== \"string\" || slug.length === 0) {\n            throw new CodegenError(\n                \"A collection has no slug, so it has no name to generate a type for. \" +\n                \"Every collection needs a unique `slug`.\"\n            );\n        }\n\n        const safe = toSafeIdentifier(slug);\n        if (safe.length === 0) {\n            throw new CodegenError(\n                `The slug ${emitString(slug)} has no characters that can form a property name, ` +\n                \"so it cannot be reached as `client.data.<name>`. Use a slug containing \" +\n                \"letters, digits, underscores or dashes.\"\n            );\n        }\n\n        const existing = bySafeName.get(safe);\n        if (existing !== undefined) {\n            throw new CodegenError(\n                `The collections ${emitString(existing)} and ${emitString(slug)} both generate the ` +\n                `accessor \"${safe}\", so only one of them could be reached from the generated client ` +\n                \"and the other's reads would silently go to the wrong table. Rename one of the slugs.\"\n            );\n        }\n\n        bySafeName.set(safe, slug);\n        accessors.set(slug, safe);\n    }\n\n    return accessors;\n}\n\n/** One emitted `key: type;` line, already indented. */\nfunction line(key: string, type: string, optional: boolean): string {\n    return `      ${emitKey(key)}${optional ? \"?\" : \"\"}: ${type};`;\n}\n\n/**\n * The keys `excludeFromApi` takes off the API surface — in *both* directions.\n *\n * `excludeFromApi` means one thing: the API surface does not mention this\n * property. `Row` already honoured that; `Insert` and `Update` deliberately did\n * not, on the reading that the column is stripped from responses rather than\n * from writes. That left the generated types as the one place a password hash\n * was still named, and it invited a client to send one. The server still\n * *accepts* such a field on a write — this describes the surface, it does not\n * add an enforcement point — but nothing generated advertises it.\n *\n * Keyed by the property name *and* by its column name, the same pair the\n * server's `stripExcluded` deletes, so a foreign key or a relation addressed\n * under the column name cannot put the property back.\n */\nfunction excludedApiKeys(properties: Properties): Set<string> {\n    const excluded = new Set<string>();\n    for (const [key, rawProp] of Object.entries(properties)) {\n        const prop = rawProp as Property;\n        if (!prop?.excludeFromApi) continue;\n        excluded.add(key);\n        if (prop.columnName) excluded.add(prop.columnName);\n    }\n    return excluded;\n}\n\nexport function generateTypedefs(input: CollectionConfig[]): string {\n    // Sorted here rather than only in `generate-sdk`: the output is\n    // order-dependent and `rebase doctor` regenerates it in memory to diff\n    // against the file on disk. While only the writer sorted, a project whose\n    // file order differed from its slug order was reported permanently stale.\n    const collections = sortCollectionsBySlug(input);\n    const accessors = buildAccessors(collections);\n    const lines: string[] = [\n        \"/**\",\n        \" * This file was auto-generated by Rebase.\",\n        \" * Do not make direct changes to the file.\",\n        \" */\",\n        \"\",\n        \"export interface Database {\"\n    ];\n\n    for (const collection of collections) {\n        const properties = (collection.properties ?? {}) as Properties;\n\n        // Resolve relations\n        let resolvedRelations: Record<string, ResolvedRelation> = {};\n        try {\n            resolvedRelations = resolveCollectionRelations(collection);\n        } catch (e) {\n            // Swallowed before, which made this the quietest way to ship a\n            // wrong type. The foreign-key columns are emitted from the resolved\n            // relations rather than from the properties, so losing them drops\n            // both the relation fields *and* columns that exist in the\n            // database — and the resulting error surfaces in the user's code,\n            // typechecking against a `Database` that is missing `author_id`,\n            // with nothing pointing back at generation.\n            //\n            // A target thunk usually throws because of a circular import; the\n            // boot-time relation validator names the same cause.\n            console.warn(\n                `[rebase] Could not resolve the relations of \"${collection.slug}\", so its generated ` +\n                \"type has no relation fields and none of their foreign-key columns. This is usually a \" +\n                \"circular import in the collection files — make sure the target is `() => otherCollection` \" +\n                `and not evaluated at module load.\\n  ${e instanceof Error ? e.message : String(e)}`\n            );\n        }\n\n        // Subcollections are collections in their own right and are addressed\n        // over a nested path, not as `client.data.<name>`. Generating them here\n        // would invent an accessor the client does not serve, so they are\n        // skipped — loudly, because doing it silently is how a developer\n        // concludes the generator is broken.\n        const subcollections = (collection as unknown as { subcollections?: unknown[] }).subcollections;\n        if (Array.isArray(subcollections) && subcollections.length > 0) {\n            console.warn(\n                `[rebase] \"${collection.slug}\" declares ${subcollections.length} subcollection(s), which are ` +\n                \"not part of the generated Database: they are reached over a nested path \" +\n                `(\\`data/${collection.slug}/<id>/<relation>\\`), not as a top-level accessor. Register a ` +\n                \"subcollection as a collection of its own if you want a typed accessor for it.\"\n            );\n        }\n\n        lines.push(`  ${emitKey(accessors.get(collection.slug)!)}: {`);\n\n        // ── Row Type ──\n        //\n        // What a read serves. There is no field selection in the query API, so\n        // every column of a row comes back on every read; a column is optional\n        // here only because the value may be absent or null, never because the\n        // caller might not have asked for it.\n        lines.push(\"    Row: {\");\n        const emittedKeys = new Set<string>();\n\n        // Off the surface entirely — see `excludedApiKeys`. Seeding the emitted\n        // set means every later pass (foreign keys, relations, unresolved\n        // relations) skips them too, since each of those already refuses to\n        // emit a key twice.\n        const excluded = excludedApiKeys(properties);\n        for (const key of excluded) emittedKeys.add(key);\n\n        // 1. Direct properties\n        for (const [key, rawProp] of Object.entries(properties)) {\n            const prop = rawProp as Property;\n            if (prop.type === \"relation\") continue;\n            if (excluded.has(key)) continue;\n\n            const tsType = propertyToTypeScriptType(prop);\n            // A primary key is on every row a read can return, whether or not\n            // anyone wrote `validation: { required: true }` next to it —\n            // introspection never does, so `row.id` was `string | undefined`\n            // for every baas project.\n            const isRequired = Boolean(prop.validation?.required) || isPrimaryKey(prop);\n            lines.push(line(key, isRequired ? tsType : `${tsType} | null`, !isRequired));\n            emittedKeys.add(key);\n        }\n\n        // 2. FK columns from relations.\n        //\n        // Emitted under `localKey` verbatim: that is the Drizzle field key, so\n        // it is the JSON key the row arrives with. Reshaping it into\n        // `authorId` described a column that does not exist and hid the one\n        // that does — including from `where` and `orderBy`, which are keyed off\n        // this type.\n        for (const [relKey, relation] of Object.entries(resolvedRelations)) {\n            if (relation.kind === \"belongsTo\" && relation.localKey) {\n                const fkKey = relation.localKey;\n                if (emittedKeys.has(fkKey)) continue;\n\n                const fkType = foreignKeyType(relation);\n\n                // A relation addressed by the same name as its own foreign key\n                // is served *over* that column when the read includes it: the\n                // query nests the target under the relation name, and the\n                // scalar it shadows is gone. Both outcomes are real, so the\n                // column is typed as both — which is what stops a plain\n                // `const id: string = row.author_id` from compiling.\n                const shadowedByInclude = relKey === fkKey;\n                const tsType = shadowedByInclude\n                    ? `${fkType} | ${includedRelationType(relation, accessors)}`\n                    : fkType;\n\n                const isRequired = Boolean(relation.validation?.required) && !shadowedByInclude;\n                lines.push(line(fkKey, isRequired ? tsType : `${tsType} | null`, !isRequired));\n                emittedKeys.add(fkKey);\n            }\n        }\n\n        // 3. Relation fields — the target's own row, inlined.\n        //\n        // Optional throughout: a relation is only loaded when the read names it\n        // in `include`, so it is absent from every other read.\n        for (const [key, relation] of Object.entries(resolvedRelations)) {\n            if (emittedKeys.has(key)) continue;\n            lines.push(line(key, includedRelationType(relation, accessors), true));\n            emittedKeys.add(key);\n        }\n\n        // A `relation` property whose relation could not be resolved — an\n        // engine without relation support, or a target that did not load. It is\n        // still a column on the row, so it is still typed, just not precisely.\n        for (const [key, rawProp] of Object.entries(properties)) {\n            if ((rawProp as Property).type !== \"relation\") continue;\n            if (emittedKeys.has(key)) continue;\n            lines.push(line(key, \"Record<string, unknown>\", true));\n            emittedKeys.add(key);\n        }\n        lines.push(\"    };\");\n\n        // ── Insert Type ──\n        //\n        // What `create()` accepts, minus the `excludeFromApi` columns: the\n        // property is off the API surface in both directions, so a generated\n        // client never names it.\n        lines.push(\"    Insert: {\");\n        emittedKeys.clear();\n        for (const key of excluded) emittedKeys.add(key);\n\n        for (const [key, rawProp] of Object.entries(properties)) {\n            const prop = rawProp as Property;\n            if (prop.type === \"relation\") continue;\n            if (excluded.has(key)) continue;\n            const tsType = propertyToTypeScriptType(prop);\n            const isOptional = !prop.validation?.required || isAutoAssignedId(prop);\n            lines.push(line(key, tsType, isOptional));\n            emittedKeys.add(key);\n        }\n\n        emitWritableRelations(lines, properties, resolvedRelations, emittedKeys, false);\n        lines.push(\"    };\");\n\n        // ── Update Type ──\n        //\n        // Everything optional, and the primary key left out: an update\n        // addresses a row by id, it does not reassign one. Accepting `id` here\n        // typechecked `update(id, { id: someoneElses })`.\n        lines.push(\"    Update: {\");\n        emittedKeys.clear();\n        for (const key of excluded) emittedKeys.add(key);\n        for (const [key, rawProp] of Object.entries(properties)) {\n            const prop = rawProp as Property;\n            if (prop.type === \"relation\") continue;\n            if (isPrimaryKey(prop)) continue;\n            if (excluded.has(key)) continue;\n            lines.push(line(key, propertyToTypeScriptType(prop), true));\n            emittedKeys.add(key);\n        }\n        emitWritableRelations(lines, properties, resolvedRelations, emittedKeys, true);\n        lines.push(\"    };\");\n\n        lines.push(\"  };\");\n    }\n\n    lines.push(\"}\");\n    lines.push(\"\");\n    lines.push(\"export type CollectionName = keyof Database;\");\n    lines.push(\"\");\n    lines.push(\"export const collectionsDictionary = {\");\n    for (const collection of collections) {\n        lines.push(`  ${emitKey(accessors.get(collection.slug)!)}: ${emitString(collection.slug)},`);\n    }\n    lines.push(\"} as const;\");\n    lines.push(\"\");\n    // Describes the const above rather than restating its keys. The previous\n    // `{ [K in CollectionName]: K }` said every value equalled its key, which is\n    // false for any slug that is not already an identifier — `myNotes` maps to\n    // `\"my-notes\"` — so the export the CLI tells people to pass did not satisfy\n    // its own published type.\n    lines.push(\"export type CollectionsDictionary = typeof collectionsDictionary;\");\n    lines.push(\"\");\n\n    return lines.join(\"\\n\");\n}\n\n/**\n * The two ways a write can name a `belongsTo` target, both of which the server\n * accepts: the foreign-key column itself (`{ author_id: 5 }`, which passes\n * through untouched) and the relation *property* (`{ author: 5 }`, which the\n * write transformer maps onto that column).\n *\n * Only the first was generated, so the documented and idiomatic write shape was\n * a type error.\n *\n * The second form is emitted under the **property key**, not the resolved\n * relation name, because that is what the transformer keys off: it looks the\n * payload key up in `properties` and only treats it as a relation if what it\n * finds there is one. A relation whose `relationName` differs from its property\n * key is reachable as the property and not as the name, so emitting the name\n * would have offered a key that writes to a column that does not exist.\n */\nfunction emitWritableRelations(\n    lines: string[],\n    properties: Properties,\n    resolvedRelations: Record<string, ResolvedRelation>,\n    emittedKeys: Set<string>,\n    allOptional: boolean\n): void {\n    // The target's primary key type is the same one `Row` uses. A hardcoded\n    // `string | number` here accepted a string for a numeric-keyed target.\n    const emit = (key: string, relation: ResolvedRelation): void => {\n        if (emittedKeys.has(key)) return;\n        const optional = allOptional || !relation.validation?.required;\n        lines.push(line(key, foreignKeyType(relation), optional));\n        emittedKeys.add(key);\n    };\n\n    for (const relation of Object.values(resolvedRelations)) {\n        if (relation.kind === \"belongsTo\" && relation.localKey) emit(relation.localKey, relation);\n    }\n\n    for (const [key, rawProp] of Object.entries(properties)) {\n        if ((rawProp as Property).type !== \"relation\") continue;\n        const relation = findRelation(resolvedRelations, key);\n        if (relation?.kind === \"belongsTo\" && relation.localKey) emit(key, relation);\n    }\n}\n","/**\n * @rebasepro/codegen\n *\n * Generates a purely typed Typescript database definition.\n */\n\nimport { CollectionConfig } from \"@rebasepro/types\";\nimport { generateTypedefs } from \"./generate-types\";\n\nexport { generateTypedefs, CodegenError } from \"./generate-types\";\nexport { toPascalCase, toCamelCase, toSafeIdentifier, indent } from \"./utils\";\n\n// ─── Public API ────────────────────────────────────────────────────\n\nexport interface GeneratedFile {\n    /** Relative file path within the output directory */\n    path: string;\n    /** File content */\n    content: string;\n}\n\nexport interface GenerateSDKOptions {\n    /** Whether to include a README file (default: true) */\n    includeReadme?: boolean;\n}\n\nexport function generateSDK(\n    collections: CollectionConfig[],\n    options: GenerateSDKOptions = {}\n): GeneratedFile[] {\n    const files: GeneratedFile[] = [];\n\n    files.push({\n        path: \"database.types.ts\",\n        content: generateTypedefs(collections)\n    });\n\n    if (options.includeReadme !== false) {\n        files.push({\n            path: \"README.md\",\n            content: `# Rebase SDK\n\n> Auto-generated by \\`rebase generate-sdk\\`. Do not edit manually.\n\n## Usage\n\n1. Install the client package:\n   \\`\\`\\`bash\n   npm install @rebasepro/client\n   \\`\\`\\`\n\n2. Initialize with your generated types:\n   \\`\\`\\`typescript\n    import { createRebaseClient } from '@rebasepro/client';\n    import { collectionsDictionary, type Database } from './database.types';\n\n    const rebase = createRebaseClient<Database>({\n        baseUrl: 'http://localhost:3001',\n        // Maps each accessor back to the slug the wire uses. Without it a\n        // hyphenated slug is not resolvable from the property name alone.\n        collections: collectionsDictionary,\n    });\n\n   // Property access is the typed surface: rows, filters and sorts are all\n   // checked against the generated Database.\n   const { data: users } = await rebase.data.users.find();\n   console.log(users[0].email); // flat access — no .values wrapper\n   \\`\\`\\`\n\n## Field names are the ones the API serves\n\nThe generated \\`Row\\` uses each column's real name, unchanged — a \\`created_at\\`\ncolumn is \\`row.created_at\\`, not \\`row.createdAt\\`. \\`where\\` and \\`orderBy\\` are keyed\noff the same type, so what compiles is what the backend answers to.\n\nOnly the *collection accessor* is turned into a property name\n(\\`my-notes\\` → \\`rebase.data.myNotes\\`), which is what \\`collectionsDictionary\\` maps\nback.\n\n## \\`Row\\` vs \\`Insert\\` vs \\`Update\\`\n\n| Type | What it describes |\n|---|---|\n| \\`Row\\` | What a read serves. Nullable columns are \\`T \\\\| null\\`; relations appear only when \\`include\\` names them. |\n| \\`Insert\\` | What \\`create()\\` accepts. Server-assigned ids are optional; a \\`belongsTo\\` target may be named either way (\\`{ author: 5 }\\` or \\`{ author_id: 5 }\\`). |\n| \\`Update\\` | What \\`update()\\` accepts. Everything optional, and the primary key is not settable. |\n\nA property marked \\`excludeFromApi\\` is absent from all three: the API surface\ndoes not mention it, in either direction. The server still accepts one on a\nwrite — these types describe the surface, they do not enforce it — but nothing\ngenerated names a password hash.\n\nIf you need an untyped escape hatch, \\`rebase.data.collection(slug)\\` still works —\nbut it is generic over \\`Record<string, unknown>\\` and gives up everything above.\n`\n        });\n    }\n\n    return files;\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rebasepro/codegen",
-  "version": "0.13.0",
+  "version": "0.13.1-canary.g06dbe5b",
   "description": "Generate a typed JS SDK from Rebase collection definitions",
   "main": "./dist/index.es.js",
   "module": "./dist/index.es.js",
@@ -22,8 +22,7 @@
   "author": "rebase.pro",
   "license": "MIT",
   "peerDependencies": {
-    "@rebasepro/common": "0.13.0",
-    "@rebasepro/types": "0.13.0"
+    "@rebasepro/types": "0.13.1-canary.g06dbe5b"
   },
   "devDependencies": {
     "@jest/globals": "^30.4.1",
@@ -33,8 +32,7 @@
     "ts-jest": "^29.4.12",
     "typescript": "^6.0.3",
     "vite": "^8.1.5",
-    "@rebasepro/types": "0.13.0",
-    "@rebasepro/common": "0.13.0"
+    "@rebasepro/types": "0.13.1-canary.g06dbe5b"
   },
   "exports": {
     ".": {
@@ -44,7 +42,7 @@
   },
   "gitHead": "d935eefa5aa8d1009a2398cfac2c1e4ee9aeb6b6",
   "dependencies": {
-    "@rebasepro/client": "0.13.0"
+    "@rebasepro/common": "0.13.1-canary.g06dbe5b"
   },
   "repository": {
     "type": "git",