npm - @rebasepro/codegen - Versions diffs - 0.13.1-canary.g3660bd5 → 0.13.1-canary.g501e3cb - Mend

@rebasepro/codegen 0.13.1-canary.g3660bd5 → 0.13.1-canary.g501e3cb

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/README.md CHANGED Viewed

@@ -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,49 @@ 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 still writable.
+   - `Update` — what `update()` accepts. Everything optional, primary key
+     omitted.
 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 +82,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 CHANGED Viewed

@@ -1,2 +1,13 @@
 import { CollectionConfig } from "@rebasepro/types";
+/**
+ * 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(collections: CollectionConfig[]): string;

package/dist/index.d.ts CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -1,4 +1,4 @@
-import { resolveCollectionRelations } from "@rebasepro/common";
+import { findRelation, resolveCollectionRelations } 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,43 @@ 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;
 }
+/**
+* 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};`;
+}
 function generateTypedefs(collections) {
-	const knownSlugs = new Set(collections.map((c) => c.slug).filter(Boolean));
+	const accessors = buildAccessors(collections);
 	const lines = [
 		"/**",
 		" * This file was auto-generated by Rebase.",
@@ -124,7 +225,6 @@ function generateTypedefs(collections) {
 		"export interface Database {"
 	];
 	for (const collection of collections) {
-		toPascalCase(collection.slug);
 		const properties = collection.properties ?? {};
 		let resolvedRelations = {};
 		try {
@@ -132,15 +232,18 @@ function generateTypedefs(collections) {
 		} 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)}`);
 		}
-		lines.push(`  ${toSafeIdentifier(collection.slug)}: {`);
+		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();
 		for (const [key, rawProp] of Object.entries(properties)) {
 			const prop = rawProp;
 			if (prop.type === "relation") continue;
+			if (prop.excludeFromApi) 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) {
@@ -148,20 +251,20 @@ 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("    };");
@@ -171,51 +274,67 @@ function generateTypedefs(collections) {
 			const prop = rawProp;
 			if (prop.type === "relation") 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, 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;
+			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 = {}) {
@@ -240,25 +359,46 @@ 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; \`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 }\`). |
+| \`Update\` | What \`update()\` accepts. Everything optional, and the primary key is not settable. |
+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 CHANGED Viewed

	@@ -1 +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 (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 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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"}
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, Property, Properties, MapProperty, ArrayProperty, StringProperty, NumberProperty, ResolvedRelation } from \"@rebasepro/types\";\nimport { findRelation, resolveCollectionRelations } 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\nexport function generateTypedefs(collections: CollectionConfig[]): string {\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 // 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 // `excludeFromApi` is a server-side guarantee that the column is\n // stripped from every row the API serves, for every caller. Typing\n // it as readable is a lie the scaffolded `users` collection makes\n // about its own password hash.\n if (prop.excludeFromApi) 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. `excludeFromApi` columns are included: they\n // are stripped from responses, not from writes.\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 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, rawProp] of Object.entries(properties)) {\n const prop = rawProp as Property;\n if (prop.type === \"relation\") continue;\n if (isPrimaryKey(prop)) 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; \\`excludeFromApi\\` columns are absent. \|\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\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 CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@rebasepro/codegen",
-  "version": "0.13.1-canary.g3660bd5",
+  "version": "0.13.1-canary.g501e3cb",
   "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.1-canary.g3660bd5",
-    "@rebasepro/types": "0.13.1-canary.g3660bd5"
+    "@rebasepro/types": "0.13.1-canary.g501e3cb"
   },
   "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.1-canary.g3660bd5",
-    "@rebasepro/common": "0.13.1-canary.g3660bd5"
+    "@rebasepro/types": "0.13.1-canary.g501e3cb"
   },
   "exports": {
     ".": {
@@ -44,7 +42,7 @@
   },
   "gitHead": "d935eefa5aa8d1009a2398cfac2c1e4ee9aeb6b6",
   "dependencies": {
-    "@rebasepro/client": "0.13.1-canary.g3660bd5"
+    "@rebasepro/common": "0.13.1-canary.g501e3cb"
   },
   "repository": {
     "type": "git",