@rebasepro/sdk-generator 0.0.1-canary.4d4fb3e

package/dist/types/src/types/user_management_delegate.d.ts

@@ -0,0 +1,120 @@
+import { Role, User } from "../users";
+/**
+ * Result of creating a new user via admin flow.
+ * Contains the created user plus information about how credentials were delivered.
+ */
+export interface UserCreationResult<USER extends User = User> {
+    /** The created user */
+    user: USER;
+    /** Whether an invitation email was sent to the user */
+    invitationSent: boolean;
+    /**
+     * Temporary password (only present when email service is not configured).
+     * This is returned one-time and should be shown to the admin to share manually.
+     */
+    temporaryPassword?: string;
+}
+/**
+ * Delegate to manage users, roles, and their permissions.
+ * This interface allows the CMS to be completely agnostic of the underlying
+ * authentication provider or backend.
+ *
+ * @group Models
+ */
+export interface UserManagementDelegate<USER extends User = User> {
+    /**
+     * Are the users and roles currently being fetched?
+     */
+    loading: boolean;
+    /**
+     * List of users managed by the CMS.
+     */
+    users: USER[];
+    /**
+     * Optional error if users failed to load.
+     */
+    usersError?: Error;
+    /**
+     * Function to get a user by its uid. This is used to show
+     * user information when assigning ownership of an entity.
+     * @param uid
+     */
+    getUser: (uid: string) => USER | null;
+    /**
+     * Search users with server-side pagination.
+     * When provided, the CMS will use this for the users table
+     * instead of loading all users into memory.
+     */
+    searchUsers?: (options: {
+        search?: string;
+        limit?: number;
+        offset?: number;
+        orderBy?: string;
+        orderDir?: "asc" | "desc";
+    }) => Promise<{
+        users: USER[];
+        total: number;
+    }>;
+    /**
+     * Save a user (create or update)
+     * @param user
+     */
+    saveUser?: (user: USER) => Promise<USER>;
+    /**
+     * Create a new user with invitation/password generation support.
+     * Returns additional info about how the credentials were delivered.
+     * Falls back to saveUser if not provided.
+     */
+    createUser?: (user: USER) => Promise<UserCreationResult<USER>>;
+    /**
+     * Reset the password for an existing user.
+     * Returns a temporary password if no email service is configured,
+     * or a flag indicating an email invitation was sent.
+     */
+    resetPassword?: (user: USER) => Promise<UserCreationResult<USER>>;
+    /**
+     * Delete a user
+     * @param user
+     */
+    deleteUser?: (user: USER) => Promise<void>;
+    /**
+     * List of roles defined in the CMS.
+     */
+    roles?: Role[];
+    /**
+     * Optional error if roles failed to load.
+     */
+    rolesError?: Error;
+    /**
+     * Save a role (create or update)
+     * @param role
+     */
+    saveRole?: (role: Role) => Promise<void>;
+    /**
+     * Delete a role
+     * @param role
+     */
+    deleteRole?: (role: Role) => Promise<void>;
+    /**
+     * Is the currently logged in user an admin?
+     */
+    isAdmin?: boolean;
+    /**
+     * If true, the UI will allow the user to create the default roles (admin, editor, viewer).
+     */
+    allowDefaultRolesCreation?: boolean;
+    /**
+     * Should collection config permissions be included?
+     */
+    includeCollectionConfigPermissions?: boolean;
+    /**
+     * Optionally define roles for a given user. This is useful when the roles
+     * are coming from a separate provider than the one issuing the tokens.
+     */
+    defineRolesFor?: (user: USER) => Promise<Role[] | undefined> | Role[] | undefined;
+    /**
+     * Optional function to bootstrap an admin user.
+     * Often used when the database is empty.
+     */
+    bootstrapAdmin?: () => Promise<void>;
+}

package/dist/types/src/types/websockets.d.ts

@@ -0,0 +1,78 @@
+import { Entity } from "./entities";
+export interface WebSocketErrorPayload {
+    error?: string | {
+        message: string;
+        code?: string;
+    };
+    message?: string;
+    code?: string;
+}
+export interface WebSocketMessage {
+    type: string;
+    payload?: unknown;
+    subscriptionId?: string;
+    requestId?: string;
+    entities?: Entity<Record<string, unknown>>[];
+    entity?: Entity<Record<string, unknown>> | null;
+    error?: string;
+}
+export interface CollectionUpdateMessage extends WebSocketMessage {
+    type: "collection_update";
+    subscriptionId: string;
+    entities: Entity<Record<string, unknown>>[];
+}
+export interface EntityUpdateMessage extends WebSocketMessage {
+    type: "entity_update";
+    subscriptionId: string;
+    entity: Entity<Record<string, unknown>> | null;
+}
+/**
+ * Lightweight patch message sent to collection subscribers when a single
+ * entity is created, updated, or deleted. The client can merge this into
+ * its cached collection data for near-instant cross-tab updates without
+ * waiting for a full collection refetch.
+ */
+export interface CollectionEntityPatchMessage extends WebSocketMessage {
+    type: "collection_entity_patch";
+    subscriptionId: string;
+    entityId: string;
+    /** The updated entity, or null if deleted */
+    entity: Entity<Record<string, unknown>> | null;
+}
+/**
+ * Column metadata returned by table introspection.
+ */
+export interface TableColumnInfo {
+    column_name: string;
+    data_type: string;
+    udt_name: string;
+    is_nullable: string;
+    column_default: string | null;
+    character_maximum_length: number | null;
+    /** Enum values, populated for USER-DEFINED (enum) columns */
+    enum_values?: string[];
+}
+export interface TableForeignKeyInfo {
+    column_name: string;
+    foreign_table_name: string;
+    foreign_column_name: string;
+}
+export interface TableJunctionInfo {
+    junction_table_name: string;
+    source_column_name: string;
+    target_table_name: string;
+    target_column_name: string;
+}
+export interface TablePolicyInfo {
+    policy_name: string;
+    roles: string[];
+    cmd: string;
+    qual?: string;
+    with_check?: string;
+}
+export interface TableMetadata {
+    columns: TableColumnInfo[];
+    foreignKeys: TableForeignKeyInfo[];
+    junctions: TableJunctionInfo[];
+    policies: TablePolicyInfo[];
+}

package/dist/types/src/users/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./user";
+export * from "./roles";

package/dist/types/src/users/roles.d.ts

@@ -0,0 +1,22 @@
+export type Role = {
+    /**
+     * ID of the role
+     */
+    id: string;
+    /**
+     * Name of the role
+     */
+    name: string;
+    /**
+     * If this flag is true, the user can perform any action
+     */
+    isAdmin?: boolean;
+    /**
+     * Permissions related to editing the collections
+     */
+    config?: {
+        createCollections?: boolean;
+        editCollections?: boolean | "own";
+        deleteCollections?: boolean | "own";
+    };
+};

package/dist/types/src/users/user.d.ts

@@ -0,0 +1,46 @@
+/**
+ * This interface represents a user.
+ * It has some of the same fields as a Firebase User.
+ * Note that in the default implementation, we simply take the Firebase user
+ * and use it as a Rebase user, so that means that even if they are not mapped
+ * in this interface, it contains all the methods of the former, such as `delete`,
+ * `getIdToken`, etc.
+ *
+ * @group Models
+ */
+export type User = {
+    /**
+     * The user's unique ID, scoped to the project.
+     */
+    readonly uid: string;
+    /**
+     * The display name of the user.
+     */
+    readonly displayName: string | null;
+    /**
+     * The email of the user.
+     */
+    readonly email: string | null;
+    /**
+     * The profile photo URL of the user.
+     */
+    readonly photoURL: string | null;
+    /**
+     * The provider used to authenticate the user.
+     */
+    readonly providerId: string;
+    /**
+     *
+     */
+    readonly isAnonymous: boolean;
+    /**
+     * Role IDs assigned to this user (e.g. ["admin", "editor"]).
+     * These are plain string IDs — use the UserManagementDelegate to look up full Role objects.
+     */
+    roles?: string[];
+    /**
+     * The date and time when the user was created.
+     */
+    createdAt?: Date | string | null;
+    getIdToken?: (forceRefresh?: boolean) => Promise<string>;
+};

package/jest.config.cjs

@@ -0,0 +1,13 @@
+/** @type {import("ts-jest").JestConfigWithTsJest} */
+module.exports = {
+    preset: "ts-jest",
+    testEnvironment: "node",
+    testMatch: [
+        "**/test/**/*.test.ts",
+        "**/src/**/*.test.ts"
+    ],
+    moduleNameMapper: {
+        "^@rebasepro/types$": "<rootDir>/../types/src",
+        "^@rebasepro/common$": "<rootDir>/../common/src",
+    }
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+    "name": "@rebasepro/sdk-generator",
+    "version": "0.0.1-canary.4d4fb3e",
+    "description": "Generate a typed JS SDK from Rebase collection definitions",
+    "main": "./dist/index.cjs",
+    "module": "./dist/index.es.js",
+    "types": "./dist/index.d.ts",
+    "type": "module",
+    "source": "src/index.ts",
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "test": "jest --config jest.config.cjs",
+        "build": "vite build && tsc --emitDeclarationOnly -p tsconfig.json",
+        "clean": "rm -rf dist && find ./src -name '*.js' -type f | xargs rm -f"
+    },
+    "keywords": [
+        "sdk",
+        "codegen",
+        "rebase",
+        "rest-api"
+    ],
+    "author": "rebase.pro",
+    "license": "MIT",
+    "peerDependencies": {
+        "@rebasepro/common": "workspace:*",
+        "@rebasepro/types": "workspace:*"
+    },
+    "devDependencies": {
+        "@rebasepro/common": "0.0.1-canary.4d4fb3e",
+        "@rebasepro/types": "0.0.1-canary.4d4fb3e",
+        "@types/jest": "^29.5.14",
+        "@types/node": "^20.19.17",
+        "jest": "^29.7.0",
+        "ts-jest": "^29.3.4",
+        "typescript": "^5.9.3",
+        "vite": "^7.2.4"
+    },
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.es.js",
+            "require": "./dist/index.cjs"
+        }
+    },
+    "gitHead": "71bcef3c51a458cd054f7924cc18efbbe515dcc8",
+    "dependencies": {
+        "@rebasepro/client": "0.0.1-canary.4d4fb3e"
+    }
+}

package/src/generate-types.ts

@@ -0,0 +1,176 @@
+import { EntityCollection, PostgresCollection, Property, Properties, MapProperty, ArrayProperty, RelationProperty, StringProperty, NumberProperty } from "@rebasepro/types";
+import { resolveCollectionRelations } from "@rebasepro/common";
+import { toPascalCase, toSafeIdentifier } from "./utils";
+
+function propertyToTypeScriptType(prop: Property): string {
+    switch (prop.type) {
+        case "string": {
+            const sp = prop as StringProperty;
+            if (sp.enum) {
+                const ids = Array.isArray(sp.enum)
+                    ? sp.enum.map((e: any) => typeof e === "object" ? String(e.id) : String(e))
+                    : Object.keys(sp.enum);
+                return ids.map(v => `"${v}"`).join(" | ");
+            }
+            return "string";
+        }
+        case "number": {
+            const np = prop as NumberProperty;
+            if (np.enum) {
+                const ids = Array.isArray(np.enum)
+                    ? np.enum.map((e: any) => typeof e === "object" ? String(e.id) : String(e))
+                    : Object.keys(np.enum);
+                return ids.join(" | ");
+            }
+            return "number";
+        }
+        case "boolean":
+            return "boolean";
+        case "date":
+            return "string"; // ISO 8601 string over the wire
+        case "geopoint":
+            return "{ latitude: number; longitude: number; }";
+        case "reference":
+            return "string | number";
+        case "relation":
+            return "string | number";
+        case "map": {
+            const mapProp = prop as MapProperty;
+            if (mapProp.properties) {
+                const inner = Object.entries(mapProp.properties)
+                    .map(([k, v]) => `${toSafeIdentifier(k)}: ${propertyToTypeScriptType(v as Property)};`)
+                    .join(" ");
+                return `{ ${inner} }`;
+            }
+            return "Record<string, any>";
+        }
+        case "array": {
+            const arrProp = prop as ArrayProperty;
+            if (arrProp.of) {
+                return `Array<${propertyToTypeScriptType(arrProp.of as Property)}>`;
+            }
+            return "Array<any>";
+        }
+        default:
+            return "any";
+    }
+}
+
+export function generateTypedefs(collections: EntityCollection[]): string {
+    const lines: string[] = [
+        `/**`,
+        ` * This file was auto-generated by Rebase.`,
+        ` * Do not make direct changes to the file.`,
+        ` */`,
+        ``,
+        `export interface Database {`
+    ];
+
+    for (const collection of collections) {
+        const typeName = toPascalCase(collection.slug);
+        const properties = (collection.properties ?? {}) as Properties;
+
+        // Resolve relations
+        let resolvedRelations: Record<string, any> = {};
+        try {
+            resolvedRelations = resolveCollectionRelations(collection as PostgresCollection);
+        } catch { /* ignore */ }
+
+        lines.push(`  ${toSafeIdentifier(collection.slug)}: {`);
+        
+        // ── Row Type ──
+        lines.push(`    Row: {`);
+        const emittedKeys = new Set<string>();
+
+        // 1. Direct properties
+        for (const [key, rawProp] of Object.entries(properties)) {
+            const prop = rawProp as Property;
+            if (prop.type === "relation") continue; 
+
+            const tsType = propertyToTypeScriptType(prop);
+            const isRequired = prop.validation?.required;
+            lines.push(`      ${toSafeIdentifier(key)}${isRequired ? "" : "?"}: ${tsType};`);
+            emittedKeys.add(key);
+        }
+        
+        // 2. FK columns from relations
+        for (const [relKey, relation] of Object.entries(resolvedRelations)) {
+            if (relation.direction === "owning" && relation.cardinality === "one" && relation.localKey) {
+                const fkKey = relation.localKey;
+                if (emittedKeys.has(fkKey)) continue;
+
+                let fkType = "string | number";
+                try {
+                    const target = relation.target();
+                    if (target.properties) {
+                        const idProp = Object.entries(target.properties).find(([_, p]: [string, any]) => p.isId);
+                        if (idProp) {
+                            fkType = (idProp[1] as Property).type === "number" ? "number" : "string";
+                        }
+                    }
+                } catch { /* ignore */ }
+
+                const isRequired = relation.validation?.required;
+                lines.push(`      ${toSafeIdentifier(fkKey)}${isRequired ? "" : "?"}: ${fkType};`);
+                emittedKeys.add(fkKey);
+            }
+        }
+        lines.push(`    };`);
+
+        // ── Insert Type ──
+        lines.push(`    Insert: {`);
+        emittedKeys.clear();
+
+        for (const [key, rawProp] of Object.entries(properties)) {
+            const prop = rawProp as Property;
+            if (prop.type === "relation") continue; 
+            const tsType = propertyToTypeScriptType(prop);
+            const isRequired = prop.validation?.required;
+            const typedProp = prop as StringProperty | NumberProperty;
+            const isAutoId = "isId" in prop && typedProp.isId && typedProp.isId !== "manual" && typedProp.isId !== true;
+            const isOptional = !isRequired || isAutoId;
+            lines.push(`      ${toSafeIdentifier(key)}${isOptional ? "?" : ""}: ${tsType};`);
+            emittedKeys.add(key);
+        }
+
+        for (const [relKey, relation] of Object.entries(resolvedRelations)) {
+            if (relation.direction === "owning" && relation.cardinality === "one" && relation.localKey) {
+                const fkKey = relation.localKey;
+                if (emittedKeys.has(fkKey)) continue;
+                let fkType = "string | number";
+                // simple fallback
+                const isRequired = relation.validation?.required;
+                lines.push(`      ${toSafeIdentifier(fkKey)}${isRequired ? "" : "?"}: ${fkType};`);
+                emittedKeys.add(fkKey);
+            }
+        }
+        lines.push(`    };`);
+
+        // ── Update Type ──
+        lines.push(`    Update: {`);
+        emittedKeys.clear();
+        for (const [key, rawProp] of Object.entries(properties)) {
+            const prop = rawProp as Property;
+            if (prop.type === "relation") continue; 
+            const tsType = propertyToTypeScriptType(prop);
+            lines.push(`      ${toSafeIdentifier(key)}?: ${tsType};`);
+            emittedKeys.add(key);
+        }
+        for (const [relKey, relation] of Object.entries(resolvedRelations)) {
+            if (relation.direction === "owning" && relation.cardinality === "one" && relation.localKey) {
+                const fkKey = relation.localKey;
+                if (emittedKeys.has(fkKey)) continue;
+                lines.push(`      ${toSafeIdentifier(fkKey)}?: string | number;`);
+                emittedKeys.add(fkKey);
+            }
+        }
+        lines.push(`    };`);
+
+        lines.push(`  };`);
+    }
+
+    lines.push(`}`);
+    lines.push(``);
+
+    return lines.join("\n");
+}

package/src/index.ts

@@ -0,0 +1,71 @@
+/**
+ * @rebasepro/sdk-generator
+ *
+ * Generates a purely typed Typescript database definition.
+ */
+
+import { EntityCollection } from "@rebasepro/types";
+import { generateTypedefs } from "./generate-types";
+
+export { generateTypedefs } from "./generate-types";
+export { toPascalCase, toCamelCase, toSafeIdentifier, indent } from "./utils";
+
+// ─── Public API ────────────────────────────────────────────────────
+
+export interface GeneratedFile {
+    /** Relative file path within the output directory */
+    path: string;
+    /** File content */
+    content: string;
+}
+
+export interface GenerateSDKOptions {
+    /** Whether to include a README file (default: true) */
+    includeReadme?: boolean;
+}
+
+export function generateSDK(
+    collections: EntityCollection[],
+    options: GenerateSDKOptions = {},
+): GeneratedFile[] {
+    const files: GeneratedFile[] = [];
+
+    files.push({
+        path: "database.types.ts",
+        content: generateTypedefs(collections)
+    });
+
+    if (options.includeReadme !== false) {
+        files.push({
+            path: "README.md",
+            content: `# Rebase SDK
+
+> Auto-generated by \`rebase generate-sdk\`. Do not edit manually.
+
+## Usage
+
+1. Install the client package:
+   \`\`\`bash
+   npm install @rebasepro/client
+   \`\`\`
+
+2. Initialize with your generated types:
+   \`\`\`typescript
+   import { createRebaseClient } from '@rebasepro/client';
+   import type { Database } from './database.types';
+
+   const rebase = createRebaseClient<Database>({
+       baseUrl: 'http://localhost:3001',
+       // token: '...', // User token if not using auth module
+   });
+
+   // Both syntax styles are fully typed!
+   const { data: users } = await rebase.data.users.find();
+   const { data: posts } = await rebase.data.collection('posts').find();
+   \`\`\`
+`
+        });
+    }
+
+    return files;
+}

package/src/json-logic-js.d.ts

@@ -0,0 +1,8 @@
+declare module "json-logic-js" {
+    interface JsonLogic {
+        apply(logic: any, data?: any): any;
+        add_operation(name: string, fn: (...args: any[]) => any): void;
+    }
+    const jsonLogic: JsonLogic;
+    export default jsonLogic;
+}

package/src/utils.ts

@@ -0,0 +1,42 @@
+/**
+ * Utility functions for the SDK generator
+ */
+
+/**
+ * Convert a slug/snake_case string to PascalCase
+ * e.g. "private_notes" → "PrivateNotes"
+ */
+export function toPascalCase(str: string): string {
+    return str
+        .split(/[_\-\s]+/)
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join("");
+}
+
+/**
+ * Convert a slug/snake_case string to camelCase
+ * e.g. "private_notes" → "privateNotes"
+ */
+export function toCamelCase(str: string): string {
+    const pascal = toPascalCase(str);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+
+/**
+ * Convert a slug to a safe JS identifier
+ * e.g. "private-notes" → "privateNotes"
+ */
+export function toSafeIdentifier(str: string): string {
+    return toCamelCase(str.replace(/[^a-zA-Z0-9_]/g, "_"));
+}
+
+/**
+ * Indent a block of text by a given number of spaces
+ */
+export function indent(text: string, spaces: number): string {
+    const pad = " ".repeat(spaces);
+    return text
+        .split("\n")
+        .map(line => (line.trim() ? pad + line : line))
+        .join("\n");
+}