@rebasepro/sdk-generator 0.0.1-canary.09e5ec5

package/dist/types/src/controllers/auth.d.ts

@@ -0,0 +1,119 @@
+import { StorageSource } from "./storage";
+import { Role, User } from "../users";
+import { RebaseData } from "./data";
+/**
+ * Capabilities advertised by an auth provider.
+ * UI components use this to show/hide features dynamically
+ * (e.g. password reset, registration, session management).
+ * @group Hooks and utilities
+ */
+export interface AuthCapabilities {
+    emailPasswordLogin?: boolean;
+    googleLogin?: boolean;
+    registration?: boolean;
+    passwordReset?: boolean;
+    sessionManagement?: boolean;
+    profileUpdate?: boolean;
+    emailVerification?: boolean;
+    /** List of enabled OAuth provider IDs (e.g. ["google", "github", "discord"]) */
+    enabledProviders?: string[];
+}
+/**
+ * Controller for retrieving the logged user or performing auth related operations.
+ * Note that if you are implementing your AuthController, you probably will want
+ * to do it as the result of a hook.
+ * @group Hooks and utilities
+ */
+export type AuthController<USER extends User = User, ExtraData = unknown> = {
+    /**
+     * The user currently logged in
+     * The values can be: the user object, null if they skipped login
+     */
+    user: USER | null;
+    /**
+     * Initial loading flag. It is used not to display the login screen
+     * when the app first loads, and it has not been checked whether the user
+     * is logged in or not.
+     */
+    initialLoading?: boolean;
+    /**
+     * Loading flag. It is used to display a loading screen when the user is
+     * logging in or out.
+     */
+    authLoading: boolean;
+    /**
+     * Sign out
+     */
+    signOut: () => Promise<void>;
+    /**
+     * Error initializing the authentication
+     */
+    authError?: unknown;
+    /**
+     * Error dispatched by the auth provider
+     */
+    authProviderError?: unknown;
+    /**
+     * You can use this method to retrieve the auth token for the current user.
+     */
+    getAuthToken: () => Promise<string>;
+    /**
+     * Has the user skipped the login process
+     */
+    loginSkipped: boolean;
+    extra: ExtraData;
+    setExtra: (extra: ExtraData) => void;
+    setUser?(user: USER | null): void;
+    setUserRoles?(roles: Role[]): void;
+    /**
+     * Capabilities advertised by the auth provider.
+     * UI components use this to feature-detect what the backend supports.
+     */
+    capabilities?: AuthCapabilities;
+};
+/**
+ * Extended auth controller with common optional auth methods.
+ * Backend implementations (Rebase backend, Firebase, Supabase, etc.)
+ * extend this with their own backend-specific extras.
+ * @group Hooks and utilities
+ */
+export interface AuthControllerExtended<USER extends User = User, ExtraData = unknown> extends AuthController<USER, ExtraData> {
+    /** Login with email and password */
+    emailPasswordLogin?(email: string, password: string): Promise<void>;
+    /** Login with a Google ID token or trigger Google popup */
+    googleLogin?(idToken: string): Promise<void>;
+    /** Register a new user */
+    register?(email: string, password: string, displayName?: string): Promise<void>;
+    /** Skip login (for anonymous access if enabled) */
+    skipLogin?(): void;
+    /** Request password reset email */
+    forgotPassword?(email: string): Promise<void>;
+    /** Reset password using a token */
+    resetPassword?(token: string, password: string): Promise<void>;
+    /** Change password for the authenticated user */
+    changePassword?(oldPassword: string, newPassword: string): Promise<void>;
+    /** Update user profile */
+    updateProfile?(displayName?: string, photoURL?: string): Promise<USER>;
+}
+/**
+ * Implement this function to allow access to specific users.
+ * @group Hooks and utilities
+ */
+export type Authenticator<USER extends User = User> = (props: {
+    /**
+     * Logged-in user or null
+     */
+    user: USER | null;
+    /**
+     * AuthController
+     */
+    authController: AuthController<USER>;
+    /**
+     * Unified data access API
+     */
+    data: RebaseData;
+    /**
+     * Used storage implementation
+     */
+    storageSource: StorageSource;
+}) => boolean | Promise<boolean>;

package/dist/types/src/controllers/client.d.ts

@@ -0,0 +1,170 @@
+import { User } from "../users";
+import { RebaseData } from "./data";
+import { EmailService } from "./email";
+/**
+ * Event type for authentication state changes
+ */
+export type AuthChangeEvent = "SIGNED_IN" | "SIGNED_OUT" | "TOKEN_REFRESHED" | "USER_UPDATED";
+/**
+ * Standard session interface representing an authenticated state
+ */
+export interface RebaseSession {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number;
+    user: User;
+}
+import { StorageSource } from "./storage";
+/**
+ * Unified Authentication Client Interface
+ * Pure functional SDK interface, decoupled from UI and React hooks
+ */
+export interface AuthClient {
+    /**
+     * Get the current user from the server or cache
+     */
+    getUser(): Promise<User | null>;
+    /**
+     * Get the currently active session
+     */
+    getSession(): RebaseSession | null;
+    /**
+     * Sign out the current user and clear local session
+     */
+    signOut(): Promise<void>;
+    /**
+     * Subscribe to authentication state changes
+     */
+    onAuthStateChange(callback: (event: AuthChangeEvent, session: RebaseSession | null) => void): () => void;
+    /**
+     * Manually refresh the session token
+     */
+    refreshSession(): Promise<RebaseSession>;
+}
+/**
+ * User record as returned by the Admin API.
+ * @group Admin
+ */
+export interface AdminUser {
+    uid: string;
+    email: string;
+    displayName: string | null;
+    photoURL: string | null;
+    provider: string;
+    roles: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Role record as returned by the Admin API.
+ * @group Admin
+ */
+export interface AdminRole {
+    id: string;
+    name: string;
+    isAdmin: boolean;
+    defaultPermissions: Record<string, unknown> | null;
+    config: Record<string, unknown> | null;
+}
+/**
+ * Client-side Admin API interface.
+ * Provides user and role management operations.
+ * @group Admin
+ */
+export interface AdminAPI {
+    listUsers(): Promise<{
+        users: AdminUser[];
+    }>;
+    listUsersPaginated(options?: {
+        search?: string;
+        limit?: number;
+        offset?: number;
+        orderBy?: string;
+        orderDir?: "asc" | "desc";
+    }): Promise<{
+        users: AdminUser[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getUser(userId: string): Promise<{
+        user: AdminUser;
+    }>;
+    createUser(data: {
+        email: string;
+        displayName?: string;
+        password?: string;
+        roles?: string[];
+    }): Promise<{
+        user: AdminUser;
+    }>;
+    updateUser(userId: string, data: {
+        email?: string;
+        displayName?: string;
+        password?: string;
+        roles?: string[];
+    }): Promise<{
+        user: AdminUser;
+    }>;
+    deleteUser(userId: string): Promise<{
+        success: boolean;
+    }>;
+    listRoles(): Promise<{
+        roles: AdminRole[];
+    }>;
+    getRole(roleId: string): Promise<{
+        role: AdminRole;
+    }>;
+    createRole(data: {
+        id: string;
+        name: string;
+        isAdmin?: boolean;
+        defaultPermissions?: Record<string, unknown>;
+        config?: Record<string, unknown>;
+    }): Promise<{
+        role: AdminRole;
+    }>;
+    updateRole(roleId: string, data: {
+        name?: string;
+        isAdmin?: boolean;
+        defaultPermissions?: Record<string, unknown>;
+        config?: Record<string, unknown>;
+    }): Promise<{
+        role: AdminRole;
+    }>;
+    deleteRole(roleId: string): Promise<{
+        success: boolean;
+    }>;
+    bootstrap(): Promise<{
+        success: boolean;
+        message: string;
+        user: {
+            uid: string;
+            roles: string[];
+        };
+    }>;
+}
+/**
+ * Overarching abstraction that unites Data, Auth, Storage, and Email.
+ * Adapters for Supabase or Firebase simply need to implement this interface.
+ */
+export interface RebaseClient<DB = unknown> {
+    /** Unified Data access layer */
+    data: RebaseData;
+    /** Unified Authentication layer */
+    auth: AuthClient;
+    /** Unified Storage layer */
+    storage?: StorageSource;
+    /**
+     * Server-side email service.
+     *
+     * Available when SMTP (or a custom `sendEmail` function) is configured
+     * in the backend auth config. `undefined` when email is not configured.
+     *
+     * > **Note:** This is only available on the server-side `rebase` singleton.
+     * > The client-side SDK does not include an email service.
+     */
+    email?: EmailService;
+    /** Admin API for user and role management */
+    admin?: AdminAPI;
+}

package/dist/types/src/controllers/collection_registry.d.ts

@@ -0,0 +1,45 @@
+import type { EntityCollection } from "../types/collections";
+import type { EntityReference } from "../types/entities";
+/**
+ * Controller that provides access to the registered entity collections.
+ * @group Models
+ */
+export type CollectionRegistryController<DB = Record<string, unknown>, EC extends EntityCollection = EntityCollection<any>> = {
+    /**
+     * List of the mapped collections in the CMS.
+     * Each entry relates to a collection in the root database.
+     * Each of the navigation entries in this field
+     * generates an entry in the main menu.
+     */
+    collections?: EntityCollection[];
+    /**
+     * Is the registry ready to be used
+     */
+    initialised: boolean;
+    /**
+     * Get the collection configuration for a given path.
+     * The collection is resolved from the given path or alias.
+     */
+    getCollection: <K extends keyof DB>(slugOrPath: Extract<K, string>, includeUserOverride?: boolean) => EC | undefined;
+    /**
+     * Get the raw, un-normalized collection configuration.
+     * This bypasses the `CollectionRegistry` normalization (such as injecting `relation` instances).
+     * This is strictly for the Visual Editor to manipulate AST code without persisting runtime state.
+     */
+    getRawCollection: (slugOrPath: string) => EC | undefined;
+    /**
+     * Retrieve all the related parent references for a given path
+     * @param path
+     */
+    getParentReferencesFromPath: (path: string) => EntityReference[];
+    /**
+     * Retrieve all the related parent collection ids for a given path
+     * @param path
+     */
+    getParentCollectionIds: (path: string) => string[];
+    /**
+     * Resolve paths from a list of ids
+     * @param ids
+     */
+    convertIdsToPaths: (ids: string[]) => string[];
+};

package/dist/types/src/controllers/customization_controller.d.ts

@@ -0,0 +1,60 @@
+import React from "react";
+import type { EntityLinkBuilder } from "../types/entity_link_builder";
+import type { Locale } from "../types/locales";
+import type { EntityAction } from "../types/entity_actions";
+import type { EntityCustomView } from "../types/entity_views";
+import type { RebasePlugin } from "../types/plugins";
+import type { PropertyConfig } from "../types/property_config";
+import type { SlotContribution } from "../types/slots";
+export type CustomizationController = {
+    /**
+     * Builder for generating utility links for entities
+     */
+    entityLinkBuilder?: EntityLinkBuilder;
+    /**
+     * Use plugins to modify the behaviour of the CMS.
+     */
+    plugins?: RebasePlugin[];
+    /**
+     * Pre-merged slots from plugins + direct slot contributions.
+     */
+    resolvedSlots: SlotContribution[];
+    /**
+     * List of additional custom views for entities.
+     * You can use the key to reference the custom view in
+     * the `entityViews` prop of a collection.
+     *
+     * You can also define an entity view from the UI.
+     */
+    entityViews?: EntityCustomView[];
+    /**
+     * List of actions that can be performed on entities.
+     * These actions are displayed in the entity view and in the collection view.
+     * You can later reuse these actions in the `entityActions` prop of a collection,
+     * by specifying the `key` of the action.
+     */
+    entityActions?: EntityAction[];
+    /**
+     * Format of the dates in the CMS.
+     * Defaults to 'MMMM dd, yyyy, HH:mm:ss'
+     */
+    dateTimeFormat?: string;
+    /**
+     * Locale of the CMS, currently only affecting dates
+     */
+    locale?: Locale;
+    /**
+     * Record of custom form fields to be used in the CMS.
+     * You can use the key to reference the custom field in
+     * the `propertyConfig` prop of a property in a collection.
+     */
+    propertyConfigs: Record<string, PropertyConfig>;
+    components?: {
+        /**
+         * Component to render when a reference is missing
+         */
+        missingReference?: React.ComponentType<{
+            path: string;
+        }>;
+    };
+};

package/dist/types/src/controllers/data.d.ts

@@ -0,0 +1,168 @@
+import { Entity, EntityValues } from "../types/entities";
+/**
+ * Parameters for querying a collection.
+ * Uses PostgREST-style filter syntax for consistency between
+ * the SDK (HTTP) and framework (in-process) contexts.
+ *
+ * @group Data
+ */
+/**
+ * A where-clause value for a single field.
+ *
+ * Supports three syntaxes:
+ *  1. **Equality shorthand**: raw JS values — `null`, `"active"`, `42`, `true`
+ *  2. **Tuple syntax**: `[operator, value]` — `[">", 18]`, `["in", ["a","b"]]`
+ *  3. **PostgREST string**: `"eq.published"`, `"gte.18"`, `"in.(a,b)"`
+ *
+ * @group Data
+ */
+export type WhereFieldValue = string | number | boolean | null | [WhereFilterOpShort, any];
+/** Short operator strings accepted in the tuple syntax. */
+export type WhereFilterOpShort = "==" | "!=" | ">" | ">=" | "<" | "<=" | "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "nin" | "not-in" | "array-contains" | "array-contains-any" | "cs" | "csa";
+export interface FindParams {
+    /** Maximum number of items to return (default: 20) */
+    limit?: number;
+    /** Number of items to skip */
+    offset?: number;
+    /** Page number (1-indexed), alternative to offset */
+    page?: number;
+    /**
+     * Filter object. Supports multiple syntaxes per field:
+     *
+     * **Equality shorthand** — raw JS values (null, string, number, boolean):
+     * ```ts
+     * { company_profile_id: null }
+     * { status: "active" }
+     * { age: 18 }
+     * ```
+     *
+     * **Tuple syntax** — `[operator, value]`:
+     * ```ts
+     * { age: [">=", 18] }
+     * { role: ["in", ["admin", "editor"]] }
+     * { deleted_at: ["!=", null] }
+     * ```
+     *
+     * **PostgREST string syntax** (original format):
+     * ```ts
+     * { status: "eq.published" }
+     * { age: "gte.18" }
+     * { role: "in.(admin,editor)" }
+     * ```
+     */
+    where?: Record<string, WhereFieldValue>;
+    /**
+     * Sort order. Format: "field:direction".
+     * @example "created_at:desc", "name:asc"
+     */
+    orderBy?: string;
+    /** Relations to include in the response */
+    include?: string[];
+    /** Full-text search string */
+    searchString?: string;
+}
+/**
+ * Paginated response from a collection query.
+ * @group Data
+ */
+export interface FindResponse<M extends Record<string, unknown> = Record<string, unknown>> {
+    /** Array of entities matching the query */
+    data: Entity<M>[];
+    /** Pagination metadata */
+    meta: {
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+    };
+}
+/**
+ * A single collection's CRUD accessor.
+ *
+ * This is the unified API surface used in both:
+ * - The generated SDK (`client.data.products.create(...)`)
+ * - Framework callbacks (`context.data.products.create(...)`)
+ *
+ * @group Data
+ */
+export interface CollectionAccessor<M extends Record<string, unknown> = Record<string, unknown>> {
+    /**
+     * Find multiple records with optional filtering, pagination, and sorting.
+     */
+    find(params?: FindParams): Promise<FindResponse<M>>;
+    /**
+     * Find a single record by its ID.
+     */
+    findById(id: string | number): Promise<Entity<M> | undefined>;
+    /**
+     * Create a new record.
+     * @param data The entity data to create.
+     * @param id Optional specific ID to use for the new record.
+     * @returns The created entity
+     */
+    create(data: Partial<EntityValues<M>>, id?: string | number): Promise<Entity<M>>;
+    /**
+     * Update an existing record by ID.
+     * @returns The updated entity
+     */
+    update(id: string | number, data: Partial<EntityValues<M>>): Promise<Entity<M>>;
+    /**
+     * Delete a record by ID.
+     */
+    delete(id: string | number): Promise<void>;
+    /**
+     * Subscribe to a collection for real-time updates.
+     * Optional method, may not be supported by all implementations (like stateless HTTP clients).
+     */
+    listen?(params: FindParams | undefined, onUpdate: (response: FindResponse<M>) => void, onError?: (error: Error) => void): () => void;
+    /**
+     * Subscribe to a single record for real-time updates.
+     * Optional method.
+     */
+    listenById?(id: string | number, onUpdate: (entity: Entity<M> | undefined) => void, onError?: (error: Error) => void): () => void;
+    /**
+     * Count the number of records matching the given filter.
+     */
+    count?(params?: FindParams): Promise<number>;
+}
+/**
+ * The unified data access object.
+ *
+ * Access collections as dynamic properties: `data.products.find(...)`.
+ * In the SDK this is backed by HTTP transport (typed, generated per-project).
+ * In the framework this is backed by a Proxy + in-process database driver (dynamic).
+ *
+ * @example
+ * // SDK
+ * const client = createRebaseClient({ baseUrl: "..." });
+ * await client.data.products.create({ name: "Camera", price: 299 });
+ *
+ * // Framework callback
+ * callbacks: {
+ *   afterSave({ context }) {
+ *     await context.data.logs.create({ action: "saved", timestamp: new Date() });
+ *   }
+ * }
+ *
+ * @group Data
+ */
+export interface RebaseData {
+    /**
+     * Get a collection accessor by slug.
+     * Alternative to dynamic property access for cases where
+     * the collection name is a variable.
+     *
+     * @example
+     * const accessor = data.collection("products");
+     * await accessor.find({ limit: 10 });
+     */
+    collection(slug: string): CollectionAccessor;
+    /**
+     * Dynamic collection accessor.
+     * Access any collection by its slug as a property.
+     *
+     * @example
+     * data.products.find({ where: { status: "eq.published" } })
+     */
+    [collectionSlug: string]: CollectionAccessor | ((slug: string) => CollectionAccessor);
+}