@rebasepro/client-postgresql 0.0.1-canary.4d4fb3e → 0.0.1-canary.ca2cb6e

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

@@ -1,9 +1,10 @@
-import { Entity, EntityCollection } from "../types";
+import type { Entity } from "../types/entities";
+import type { EntityCollection } from "../types/collections";
 /**
  * Props used to open a side dialog
  * @group Hooks and utilities
  */
-export interface EntitySidePanelProps<M extends Record<string, any> = any> {
+export interface EntitySidePanelProps<M extends Record<string, unknown> = Record<string, unknown>> {
     /**
      * Absolute path of the entity
      */
@@ -43,7 +44,7 @@ export interface EntitySidePanelProps<M extends Record<string, any> = any> {
      * @param params
      */
     onUpdate?: (params: {
-        entity: Entity<any>;
+        entity: Entity<M>;
     }) => void;
     /**
      * Callback when the dialog is closed
@@ -56,7 +57,7 @@ export interface EntitySidePanelProps<M extends Record<string, any> = any> {
     /**
      * Override some form properties
      */
-    formProps?: any;
+    formProps?: Record<string, unknown>;
     /**
      * Allow the user to open the entity fullscreen
      */
@@ -80,10 +81,10 @@ export interface SideEntityController {
      * (or a new one with that id).
      * @param props
      */
-    open: <M extends Record<string, any> = any>(props: EntitySidePanelProps<M>) => void;
+    open: <M extends Record<string, unknown> = Record<string, unknown>>(props: EntitySidePanelProps<M>) => void;
     /**
      * Replace the last open entity panel with the given one.
      * @param props
      */
-    replace: <M extends Record<string, any> = any>(props: EntitySidePanelProps<M>) => void;
+    replace: <M extends Record<string, unknown> = Record<string, unknown>>(props: EntitySidePanelProps<M>) => void;
 }

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

@@ -3,8 +3,7 @@
  */
 export interface UploadFileProps {
     file: File;
-    fileName?: string;
-    path?: string;
+    key: string;
     metadata?: Record<string, unknown>;
     bucket?: string;
 }
@@ -13,9 +12,9 @@ export interface UploadFileProps {
  */
 export interface UploadFileResult {
     /**
-     * Storage path including the file name where the file was uploaded.
+     * Storage key including the file name where the file was uploaded.
      */
-    path: string;
+    key: string;
     /**
      * Bucket where the file was uploaded
      */
@@ -23,7 +22,7 @@ export interface UploadFileResult {
     /**
      * Fully qualified storage URL for the uploaded file.
      *
-     * For example: `gs://my-bucket/path/to/file.png`.
+     * For example: `s3://my-bucket/path/to/file.png`.
      *
      * This is optional for backwards compatibility.
      */
@@ -74,39 +73,38 @@ export declare interface DownloadMetadata {
  */
 export interface StorageSource {
     /**
-     * Upload a file, specifying a name and a path
+     * Upload an object, specifying a key
      * @param file
-     * @param fileName
-     * @param path
+     * @param key
      * @param metadata
      * @param bucket
      */
-    uploadFile: ({ file, fileName, path, metadata, bucket }: UploadFileProps) => Promise<UploadFileResult>;
+    putObject: ({ file, key, metadata, bucket }: UploadFileProps) => Promise<UploadFileResult>;
     /**
-     * Convert a storage path or URL into a download configuration
-     * @param path
+     * Convert a storage key or URL into a download configuration (signed URL equivalent)
+     * @param keyOrUrl
      * @param bucket
      */
-    getDownloadURL: (pathOrUrl: string, bucket?: string) => Promise<DownloadConfig>;
+    getSignedUrl: (keyOrUrl: string, bucket?: string) => Promise<DownloadConfig>;
     /**
-     * Get a file from a storage path.
-     * It returns null if the file does not exist.
-     * @param props
+     * Get an object from a storage key.
+     * It returns null if the object does not exist.
+     * @param key
      * @param bucket
      */
-    getFile: (path: string, bucket?: string) => Promise<File | null>;
+    getObject: (key: string, bucket?: string) => Promise<File | null>;
     /**
-     * Delete a file.
-     * @param path
+     * Delete an object.
+     * @param key
      * @param bucket
      */
-    deleteFile: (path: string, bucket?: string) => Promise<void>;
+    deleteObject: (key: string, bucket?: string) => Promise<void>;
     /**
-     * List the contents of a path.
-     * @param path
+     * List the contents of a prefix.
+     * @param prefix
      * @param options
      */
-    list: (path: string, options?: {
+    listObjects: (prefix: string, options?: {
         bucket?: string;
         maxResults?: number;
         pageToken?: string;
@@ -137,15 +135,15 @@ export declare interface StorageListResult {
     nextPageToken?: string;
 }
 /**
- * Represents a reference to a Google Cloud Storage object. Developers can
+ * Represents a reference to an S3-compatible storage object. Developers can
  * upload, download, and delete objects, as well as get/set object metadata.
  * @public
  */
 export declare interface StorageReference {
     /**
-     * Returns a gs:// URL for this object in the form
-     *   `gs://<bucket>/<path>/<to>/<object>`
-     * @returns The gs:// URL.
+     * Returns a s3:// URL for this object in the form
+     *   `s3://<bucket>/<path>/<to>/<object>`
+     * @returns The s3:// URL.
      */
     toString(): string;
     /**

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

@@ -1,7 +1,11 @@
-import { AnalyticsController, AuthController, StorageSource, UserConfigurationPersistence, DatabaseAdmin } from "./controllers";
-import { RebaseData } from "./controllers/data";
-import { User } from "./users";
-import { UserManagementDelegate } from "./types/user_management_delegate";
+import type { AnalyticsController } from "./controllers/analytics_controller";
+import type { AuthController } from "./controllers/auth";
+import type { StorageSource } from "./controllers/storage";
+import type { UserConfigurationPersistence } from "./controllers/local_config_persistence";
+import type { DatabaseAdmin } from "./types/backend";
+import type { RebaseData } from "./controllers/data";
+import type { User } from "./users";
+import type { UserManagementDelegate } from "./types/user_management_delegate";
 /**
  * Context that is provided to entity callbacks (hooks).
  * It contains only the dependencies that are available in both the frontend and the backend.

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

@@ -1,4 +1,5 @@
-import { Entity, EntityCollection, FilterValues, WhereFilterOp } from "./index";
+import type { Entity } from "./entities";
+import type { EntityCollection, FilterValues, WhereFilterOp } from "./collections";
 /**
  * Abstract database connection interface.
  * Represents a connection to any database system.
@@ -33,6 +34,7 @@ export interface FetchCollectionOptions<M extends Record<string, unknown> = Reco
     orderBy?: string;
     order?: "desc" | "asc";
     limit?: number;
+    offset?: number;
     startAfter?: unknown;
     searchString?: string;
     databaseId?: string;
@@ -54,6 +56,7 @@ export interface SearchOptions<M extends Record<string, unknown> = Record<string
  */
 export interface CountOptions<M extends Record<string, unknown> = Record<string, unknown>> {
     filter?: FilterValues<Extract<keyof M, string>>;
+    searchString?: string;
     databaseId?: string;
 }
 /**

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

@@ -1,7 +1,8 @@
-import { AuthController, RebaseData } from "../controllers";
-import { User } from "../users";
-import { EntityCollection } from "./collections";
-import { AppView } from "../controllers/navigation";
+import type { AuthController } from "../controllers/auth";
+import type { RebaseData } from "../controllers/data";
+import type { User } from "../users";
+import type { EntityCollection } from "./collections";
+import type { AppView } from "../controllers/navigation";
 export type EntityCollectionsBuilder<EC extends EntityCollection = EntityCollection> = (params: {
     user: User | null;
     authController: AuthController;

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

@@ -2,4 +2,4 @@ export type ColorScheme = {
     color: string;
     text: string;
 };
-export type ColorKey = "blueLighter" | "cyanLighter" | "tealLighter" | "greenLighter" | "yellowLighter" | "orangeLighter" | "redLighter" | "pinkLighter" | "purpleLighter" | "grayLighter" | "blueLight" | "cyanLight" | "tealLight" | "greenLight" | "yellowLight" | "orangeLight" | "redLight" | "pinkLight" | "purpleLight" | "grayLight" | "blueDark" | "cyanDark" | "tealDark" | "greenDark" | "yellowDark" | "orangeDark" | "redDark" | "pinkDark" | "purpleDark" | "grayDark" | "blueDarker" | "cyanDarker" | "tealDarker" | "greenDarker" | "yellowDarker" | "orangeDarker" | "redDarker" | "pinkDarker" | "purpleDarker" | "grayDarker";
+export type ColorKey = "blue" | "cyan" | "teal" | "green" | "yellow" | "orange" | "red" | "pink" | "purple" | "gray" | "indigo" | "violet" | "fuchsia" | "rose" | "emerald";

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

@@ -1,14 +1,14 @@
 import React from "react";
-import { Entity, EntityStatus } from "./entities";
-import { EntityCallbacks } from "./entity_callbacks";
-import { Properties } from "./properties";
-import { ExportConfig } from "./export_import";
-import { EntityOverrides } from "./entity_overrides";
-import { User } from "../users";
-import { RebaseContext } from "../rebase_context";
-import { Relation } from "./relations";
-import { EntityCustomView } from "./entity_views";
-import { EntityAction } from "./entity_actions";
+import type { Entity, EntityStatus } from "./entities";
+import type { EntityCallbacks } from "./entity_callbacks";
+import type { Properties } from "./properties";
+import type { ExportConfig } from "./export_import";
+import type { EntityOverrides } from "./entity_overrides";
+import type { User } from "../users";
+import type { RebaseContext } from "../rebase_context";
+import type { Relation } from "./relations";
+import type { EntityCustomView } from "./entity_views";
+import type { EntityAction } from "./entity_actions";
 /**
  * Base interface containing all driver-agnostic collection properties.
  * Use {@link PostgresCollection} or {@link FirebaseCollection} for
@@ -98,6 +98,11 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      * Default preview properties displayed when this collection is referenced to.
      */
     previewProperties?: string[];
+    /**
+     * Properties to display as columns in the list view.
+     * If not specified, the list view uses a smart default (Title, Status, Date).
+     */
+    listProperties?: string[];
     /**
      * Title property of the entity. This is the property that will be used
      * as the title in entity related views and references.
@@ -108,7 +113,7 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      * When editing an entity, you can choose to open the entity in a side dialog
      * or in a full screen dialog. Defaults to `full_screen`.
      */
-    openEntityMode?: "side_panel" | "full_screen";
+    openEntityMode?: "side_panel" | "full_screen" | "split";
     /**
      * Order in which the properties are displayed.
      * If you are specifying your collection as code, the order is the same as the
@@ -262,7 +267,7 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
     localChangesBackup?: "manual_apply" | "auto_apply" | false;
     /**
      * Default view mode for displaying this collection.
-     * - "table": Display entities in a spreadsheet-like table (default)
+     * - "table": Display entities in a table with inline editing (default)
      * - "cards": Display entities as a grid of cards with thumbnails
      * - "kanban": Display entities in a Kanban board grouped by a property
      * Defaults to "table".
@@ -283,9 +288,10 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
     kanban?: KanbanConfig<M>;
     /**
      * Property key to use for ordering items.
-     * Must reference a number property. When items are reordered,
-     * this property will be updated to reflect the new order using
-     * fractional indexing. Used by Kanban view for ordering within columns
+     * Must reference a string/text property. When items are reordered,
+     * this property will be updated with lexicographic sort keys
+     * (e.g. "a0", "a1", "a0V") using string-based fractional indexing.
+     * Used by Kanban view for ordering within columns
      * and can be used for general ordering purposes.
      */
     readonly orderProperty?: Extract<keyof M, string> | (string & {});
@@ -317,11 +323,6 @@ export interface PostgresCollection<M extends Record<string, unknown> = Record<s
      * The PostgreSQL table name for this collection.
      */
     table: string;
-    /**
-     * Set by the backend when the resolved table name doesn't match
-     * an actual table in the database schema.
-     */
-    isTableMissing?: boolean;
     /**
      * For SQL databases, you can define the relations between collections here.
      * Relations describe JOINs, foreign keys, and junction tables.
@@ -365,14 +366,39 @@ export interface FirebaseCollection<M extends Record<string, unknown> = Record<s
      */
     subcollections?: () => EntityCollection<Record<string, unknown>>[];
 }
+/**
+ * A collection backed by MongoDB.
+ *
+ * Use this type instead of {@link EntityCollection} when you want
+ * compile-time safety that only MongoDB-relevant fields appear.
+ *
+ * @group Models
+ */
+export interface MongoDBCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> extends BaseEntityCollection<M, USER> {
+    /**
+     * The driver for this collection. Must be set to `"mongodb"`.
+     */
+    driver: "mongodb";
+}
 /**
  * A collection backed by any data source.
- * This is a discriminated union — use {@link PostgresCollection} or
- * {@link FirebaseCollection} for driver-specific type safety.
+ * This is a discriminated union — use {@link PostgresCollection},
+ * {@link FirebaseCollection}, or {@link MongoDBCollection} for
+ * driver-specific type safety.
  *
  * @group Models
  */
-export type EntityCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> = PostgresCollection<M, USER> | FirebaseCollection<M, USER>;
+export type EntityCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> = PostgresCollection<M, USER> | FirebaseCollection<M, USER> | MongoDBCollection<M, USER>;
+/** An EntityCollection that supports SQL-style relations (e.g. Postgres). */
+export type CollectionWithRelations<M extends Record<string, unknown> = Record<string, unknown>> = EntityCollection<M> & {
+    table?: string;
+    relations?: Relation[];
+    securityRules?: SecurityRule[];
+};
+/** An EntityCollection that supports subcollections (e.g. Firestore). */
+export type CollectionWithSubcollections<M extends Record<string, unknown> = Record<string, unknown>> = EntityCollection<M> & {
+    subcollections?: () => EntityCollection<Record<string, unknown>>[];
+};
 /**
  * Type guard for PostgreSQL collections.
  * Returns true if the collection uses the Postgres driver (or the default driver).
@@ -384,6 +410,11 @@ export declare function isPostgresCollection<M extends Record<string, unknown> =
  * @group Models
  */
 export declare function isFirebaseCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>(collection: EntityCollection<M, USER>): collection is FirebaseCollection<M, USER>;
+/**
+ * Type guard for MongoDB collections.
+ * @group Models
+ */
+export declare function isMongoDBCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>(collection: EntityCollection<M, USER>): collection is MongoDBCollection<M, USER>;
 /**
  * Configuration for Kanban board view mode.
  * @group Collections
@@ -399,9 +430,13 @@ export interface KanbanConfig<M extends Record<string, unknown> = Record<string,
 }
 /**
  * View mode for displaying a collection.
+ * - "list": Simple, clean list view — the classic CMS default
+ * - "table": Table with inline editing
+ * - "cards": Grid of visual cards with thumbnails
+ * - "kanban": Board view grouped by a property
  * @group Collections
  */
-export type ViewMode = "table" | "cards" | "kanban";
+export type ViewMode = "list" | "table" | "cards" | "kanban";
 /**
  * Parameter passed to the `Actions` prop in the collection configuration.
  * The component will receive this prop when it is rendered in the collection
@@ -610,9 +645,18 @@ export type SecurityOperation = "select" | "insert" | "update" | "delete" | "all
  * operation. Permissive rules are OR'd together (any one passing is enough).
  * Restrictive rules are AND'd (all must pass). This mirrors Supabase behavior.
  *
+ * **Mutual exclusivity:** `ownerField`, `access`, and raw SQL (`using`/`withCheck`)
+ * cannot be combined. The type system enforces this — attempting to set
+ * conflicting fields will produce a compile-time error.
+ *
  * @group Models
  */
-export interface SecurityRule {
+export type SecurityRule = OwnerSecurityRule | PublicSecurityRule | RawSQLSecurityRule | RolesOnlySecurityRule;
+/**
+ * Shared fields for all SecurityRule variants.
+ * @group Models
+ */
+export interface SecurityRuleBase {
     /**
      * Optional human-readable name for the policy.
      * If not provided, one will be auto-generated from the table name and operation.
@@ -664,35 +708,6 @@ export interface SecurityRule {
      * @default "permissive"
      */
     mode?: "permissive" | "restrictive";
-    /**
-     * **Shortcut.** The property (column) that stores the owner's user ID.
-     * Generates a USING/WITH CHECK clause like:
-     *   `<column> = auth.uid()`
-     *
-     * Cannot be combined with `using` / `withCheck` / `access`.
-     *
-     * @example
-     * { operation: "all", ownerField: "user_id" }
-     */
-    ownerField?: string;
-    /**
-     * **Shortcut.** Grant unrestricted row access (no row filtering) for this operation.
-     * Generates `USING (true)`.
-     *
-     * This means "no row-level filter", NOT "anonymous/unauthenticated access".
-     * Authentication is still enforced at the API layer — this only controls which
-     * *rows* authenticated users can see.
-     *
-     * Typically used alone for genuinely public read endpoints, or combined with
-     * `roles` to give certain roles an unfiltered view of the table.
-     *
-     * Cannot be combined with `using` / `withCheck` / `ownerField`.
-     *
-     * @example
-     * // Public read (any authenticated user sees all rows)
-     * { operation: "select", access: "public" }
-     */
-    access?: "public";
     /**
      * **Shortcut.** Restrict this rule to users that have one of these
      * application-level roles.
@@ -716,77 +731,6 @@ export interface SecurityRule {
      * { operation: "select", roles: ["admin"], using: "true" }
      */
     roles?: string[];
-    /**
-     * Raw SQL expression for the `USING` clause.
-     * This controls which *existing* rows are visible / can be modified / deleted.
-     * Applied to SELECT, UPDATE, and DELETE.
-     *
-     * You can reference columns via `{column_name}` which will be resolved to
-     * `table.column_name` in the generated Drizzle code. You can also use any
-     * valid PostgreSQL expression.
-     *
-     * Cannot be combined with `ownerField` or `access`.
-     *
-     * @example
-     * // Rows published in the last 30 days are visible
-     * { operation: "select", using: "{published_at} > now() - interval '30 days'" }
-     *
-     * @example
-     * // Only the owner, or users with 'moderator' role
-     * {
-     *   operation: "select",
-     *   using: "{user_id} = auth.uid() OR auth.roles() ~ 'moderator'"
-     * }
-     *
-     * @example
-     * // Cross-table subquery: only if user belongs to the org
-     * {
-     *   operation: "select",
-     *   using: "EXISTS (SELECT 1 FROM org_members WHERE org_members.org_id = {org_id} AND org_members.user_id = auth.uid())"
-     * }
-     */
-    using?: string;
-    /**
-     * Raw SQL expression for the `WITH CHECK` clause.
-     * This controls which *new/updated* row values are allowed.
-     * Applied to INSERT and UPDATE.
-     *
-     * Same syntax as `using` — use `{column_name}` to reference columns.
-     *
-     * **Important for UPDATE:** PostgreSQL evaluates two row states — the
-     * *existing* row (`USING`) and the *incoming new* row (`WITH CHECK`).
-     * If you only specify `using`, the same expression is used for both.
-     * For security-sensitive updates, always specify `withCheck` explicitly
-     * to constrain what the new row values can be.
-     *
-     * If not provided on INSERT/UPDATE policies, falls back to `using`
-     * (which matches PostgreSQL's own default behavior).
-     *
-     * Cannot be combined with `ownerField` or `access`.
-     *
-     * @example
-     * // Users can only insert rows where they are the owner
-     * { operation: "insert", withCheck: "{user_id} = auth.uid()" }
-     *
-     * @example
-     * // Prevent changing the status to 'archived' unless admin
-     * {
-     *   operation: "update",
-     *   using: "{user_id} = auth.uid()",
-     *   withCheck: "{status} != 'archived' OR auth.roles() ~ 'admin'"
-     * }
-     *
-     * @example
-     * // Restrictive gate: prevent locking AND unlocking unless admin.
-     * // `using` checks the old row state, `withCheck` checks the new.
-     * {
-     *   operation: "update",
-     *   mode: "restrictive",
-     *   using: "{is_locked} = false",
-     *   withCheck: "{is_locked} = false"
-     * }
-     */
-    withCheck?: string;
     /**
      * **Advanced.** Native PostgreSQL database roles the policy applies to.
      *
@@ -810,3 +754,103 @@ export interface SecurityRule {
      */
     pgRoles?: string[];
 }
+/**
+ * Security rule that grants access based on row ownership.
+ * Generates a USING/WITH CHECK clause like: `<column> = auth.uid()`
+ *
+ * Cannot be combined with `using`, `withCheck`, or `access`.
+ *
+ * @example
+ * { operation: "all", ownerField: "user_id" }
+ *
+ * @group Models
+ */
+export interface OwnerSecurityRule extends SecurityRuleBase {
+    /** The property (column) that stores the owner's user ID. */
+    ownerField: string;
+    access?: never;
+    using?: never;
+    withCheck?: never;
+}
+/**
+ * Security rule that grants unrestricted row access (no row filtering).
+ * Generates `USING (true)`.
+ *
+ * This means "no row-level filter", NOT "anonymous/unauthenticated access".
+ * Authentication is still enforced at the API layer — this only controls which
+ * *rows* authenticated users can see.
+ *
+ * Cannot be combined with `using`, `withCheck`, or `ownerField`.
+ *
+ * @example
+ * // Public read (any authenticated user sees all rows)
+ * { operation: "select", access: "public" }
+ *
+ * @group Models
+ */
+export interface PublicSecurityRule extends SecurityRuleBase {
+    /** Grant unrestricted row access for this operation. */
+    access: "public";
+    ownerField?: never;
+    using?: never;
+    withCheck?: never;
+}
+/**
+ * Security rule using raw SQL expressions for full PostgreSQL RLS power.
+ *
+ * Cannot be combined with `ownerField` or `access`.
+ *
+ * You can reference columns via `{column_name}` which will be resolved to
+ * `table.column_name` in the generated Drizzle code.
+ *
+ * @example
+ * // Rows published in the last 30 days are visible
+ * { operation: "select", using: "{published_at} > now() - interval '30 days'" }
+ *
+ * @example
+ * // Only the owner, or users with 'moderator' role
+ * {
+ *   operation: "select",
+ *   using: "{user_id} = auth.uid() OR auth.roles() ~ 'moderator'"
+ * }
+ *
+ * @group Models
+ */
+export interface RawSQLSecurityRule extends SecurityRuleBase {
+    /**
+     * Raw SQL expression for the `USING` clause.
+     * This controls which *existing* rows are visible / can be modified / deleted.
+     * Applied to SELECT, UPDATE, and DELETE.
+     */
+    using: string;
+    /**
+     * Raw SQL expression for the `WITH CHECK` clause.
+     * This controls which *new/updated* row values are allowed.
+     * Applied to INSERT and UPDATE.
+     *
+     * If not provided on INSERT/UPDATE policies, falls back to `using`
+     * (which matches PostgreSQL's own default behavior).
+     */
+    withCheck?: string;
+    ownerField?: never;
+    access?: never;
+}
+/**
+ * Security rule that only filters by application roles, without any
+ * row-level condition (USING/WITH CHECK).
+ *
+ * Useful for simple "only admins can access this table" rules where
+ * no per-row filtering is needed.
+ *
+ * @example
+ * // Only admins can delete
+ * { operation: "delete", roles: ["admin"] }
+ *
+ * @group Models
+ */
+export interface RolesOnlySecurityRule extends SecurityRuleBase {
+    ownerField?: never;
+    access?: never;
+    using?: never;
+    withCheck?: never;
+}