@rebasepro/server-postgresql 0.4.0 → 0.6.0

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

@@ -1,60 +0,0 @@
-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

@@ -1,207 +0,0 @@
-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] | [WhereFilterOpShort, any][];
-export type WhereValue<T> = T | T[] | null;
-export interface LogicalCondition {
-    type: "and" | "or";
-    conditions: (FilterCondition | LogicalCondition)[];
-}
-export interface FilterCondition {
-    column: string;
-    operator: FilterOperator;
-    value: unknown;
-}
-/** 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>;
-    /** Logical grouping conditions (AND/OR) */
-    logical?: LogicalCondition;
-    /**
-     * 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;
-    };
-}
-export type FilterOperator = WhereFilterOpShort;
-/**
- * Fluent Query Builder Interface supported on both client and server accessors.
- * @group Data
- */
-export interface QueryBuilderInterface<M extends Record<string, unknown> = Record<string, unknown>> {
-    where<K extends keyof M & string>(column: K, operator: FilterOperator, value: WhereValue<M[K]>): this;
-    where(logicalCondition: LogicalCondition): this;
-    orderBy(column: keyof M & string, ascending?: "asc" | "desc"): this;
-    limit(count: number): this;
-    offset(count: number): this;
-    search(searchString: string): this;
-    include(...relations: string[]): this;
-    find(): Promise<FindResponse<M>>;
-    listen(onUpdate: (data: FindResponse<M>) => void, onError?: (error: Error) => void): () => void;
-}
-/**
- * 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>;
-    /**
-     * Delete all records in this collection.
-     */
-    deleteAll?(): 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>;
-    where<K extends keyof M & string>(column: K, operator: FilterOperator, value: WhereValue<M[K]>): QueryBuilderInterface<M>;
-    where(logicalCondition: LogicalCondition): QueryBuilderInterface<M>;
-    orderBy(column: keyof M & string, ascending?: "asc" | "desc"): QueryBuilderInterface<M>;
-    limit(count: number): QueryBuilderInterface<M>;
-    offset(count: number): QueryBuilderInterface<M>;
-    search(searchString: string): QueryBuilderInterface<M>;
-    include(...relations: string[]): QueryBuilderInterface<M>;
-}
-/**
- * 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);
-}

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

@@ -1,218 +0,0 @@
-import type { Entity, EntityStatus, EntityValues } from "../types/entities";
-import type { EntityCollection, FilterValues } from "../types/collections";
-import type { RebaseContext } from "../rebase_context";
-/**
- * @internal
- */
-export interface FetchEntityProps<M extends Record<string, unknown> = Record<string, unknown>> {
-    path: string;
-    entityId: string | number;
-    databaseId?: string;
-    collection?: EntityCollection<M>;
-}
-/**
- * @internal
- */
-export type ListenEntityProps<M extends Record<string, unknown> = Record<string, unknown>> = FetchEntityProps<M> & {
-    onUpdate: (entity: Entity<M> | null) => void;
-    onError?: (error: Error) => void;
-};
-/**
- * Configuration for vector similarity search queries.
- * Vector search applies an ORDER BY distance expression and optionally
- * filters results by a distance threshold.
- */
-export interface VectorSearchParams {
-    /** Property name containing the vector column */
-    property: string;
-    /** Query vector to compare against */
-    vector: number[];
-    /** Distance function (default: "cosine") */
-    distance?: "cosine" | "l2" | "inner_product";
-    /** Only return results within this distance threshold */
-    threshold?: number;
-}
-/**
- * @internal
- */
-export interface FetchCollectionProps<M extends Record<string, unknown> = Record<string, unknown>> {
-    path: string;
-    collection?: EntityCollection<M>;
-    filter?: FilterValues<Extract<keyof M, string>>;
-    limit?: number;
-    offset?: number;
-    startAfter?: unknown;
-    orderBy?: string;
-    searchString?: string;
-    order?: "desc" | "asc";
-    /** Vector similarity search configuration */
-    vectorSearch?: VectorSearchParams;
-}
-/**
- * @internal
- */
-export type ListenCollectionProps<M extends Record<string, unknown> = Record<string, unknown>> = FetchCollectionProps<M> & {
-    onUpdate: (entities: Entity<M>[]) => void;
-    onError?: (error: Error) => void;
-};
-/**
- * @internal
- */
-export interface SaveEntityProps<M extends Record<string, unknown> = Record<string, unknown>> {
-    path: string;
-    values: Partial<EntityValues<M>>;
-    entityId?: string | number;
-    previousValues?: Partial<EntityValues<M>>;
-    collection?: EntityCollection<M>;
-    status: EntityStatus;
-}
-/**
- * @internal
- */
-export interface DeleteEntityProps<M extends Record<string, unknown> = Record<string, unknown>> {
-    entity: Entity<M>;
-    collection?: EntityCollection<M>;
-}
-export type FilterCombinationValidProps = {
-    path: string;
-    databaseId?: string;
-    collection: EntityCollection;
-    filterValues: FilterValues<string>;
-    sortBy?: [string, "asc" | "desc"];
-};
-/**
- * Internal driver interface for communicating with the data layer.
- * This is NOT the public API — use `RebaseData` / `context.data` instead.
- * @internal
- */
-export interface DataDriver {
-    /**
-     * Key that identifies this driver
-     */
-    key?: string;
-    /**
-     * If the driver has been initialised
-     */
-    initialised?: boolean;
-    /**
-     * Fetch data from a collection
-     * @param props
-     * @return Promise of entities
-     */
-    fetchCollection<M extends Record<string, unknown> = Record<string, unknown>>(props: FetchCollectionProps<M>): Promise<Entity<M>[]>;
-    /**
-     * Listen to a collection in a given path. If you don't implement this method
-     * `fetchCollection` will be used instead, with no real time updates.
-     * @param props
-     * @return Function to cancel subscription
-     */
-    listenCollection?<M extends Record<string, unknown> = Record<string, unknown>>(props: ListenCollectionProps<M>): () => void;
-    /**
-     * Retrieve an entity given a path and a collection
-     * @param props
-     */
-    fetchEntity<M extends Record<string, unknown> = Record<string, unknown>>(props: FetchEntityProps<M>): Promise<Entity<M> | undefined>;
-    /**
-     * Get realtime updates on one entity.
-     * @param props
-     * @return Function to cancel subscription
-     */
-    listenEntity?<M extends Record<string, unknown> = Record<string, unknown>>(props: ListenEntityProps<M>): () => void;
-    /**
-     * Save entity to the specified path
-     * @param props
-     */
-    saveEntity<M extends Record<string, unknown> = Record<string, unknown>>(props: SaveEntityProps<M>): Promise<Entity<M>>;
-    /**
-     * Delete an entity
-     * @param props
-     * @return was the whole deletion flow successful
-     */
-    deleteEntity<M extends Record<string, unknown> = Record<string, unknown>>(props: DeleteEntityProps<M>): Promise<void>;
-    /**
-     * Delete all entities from a collection.
-     * @param path Collection path
-     */
-    deleteAll?(path: string): Promise<void>;
-    /**
-     * Check if the given property is unique in the given collection
-     * @param path Collection path
-     * @param name of the property
-     * @param value
-     * @param entityId
-     * @param collection
-     * @return `true` if there are no other fields besides the given entity
-     */
-    checkUniqueField(path: string, name: string, value: unknown, entityId?: string | number, collection?: EntityCollection): Promise<boolean>;
-    /**
-     * Count the number of entities in a collection
-     */
-    countEntities?<M extends Record<string, unknown> = Record<string, unknown>>(props: FetchCollectionProps<M>): Promise<number>;
-    /**
-     * Check if the given filter combination is valid
-     * @param props
-     */
-    isFilterCombinationValid?(props: Omit<FilterCombinationValidProps, "collection"> & {
-        databaseId?: string;
-    }): boolean;
-    /**
-     * Get the object to generate the current time in the driver
-     */
-    currentTime?: () => unknown;
-    delegateToCMSModel?: (data: unknown) => unknown;
-    cmsToDelegateModel?: (data: unknown) => unknown;
-    initTextSearch?: (props: {
-        context: RebaseContext;
-        path: string;
-        databaseId?: string;
-        collection: EntityCollection;
-        parentCollectionSlugs?: string[];
-        parentEntityIds?: string[];
-    }) => Promise<boolean>;
-    /**
-     * Flag to indicate if the driver has requested the initialization of the text search index
-     */
-    needsInitTextSearch?: boolean;
-    /**
-     * Optional REST-optimised fetch service. When present, the REST API
-     * generator uses these methods instead of the generic `fetchEntity` /
-     * `fetchCollection` pipeline, enabling include-aware eager-loading.
-     */
-    restFetchService?: RestFetchService;
-    /**
-     * Return the admin capabilities of this driver.
-     * @see SQLAdmin
-     * @see DocumentAdmin
-     * @see SchemaAdmin
-     */
-    admin?: import("../types/backend").DatabaseAdmin;
-}
-/**
- * REST-optimised fetch service exposed by drivers that support
- * eager-loading of relations via `include`.
- *
- * The methods return flattened rows (`{ id, ...columns }`) rather
- * than the `Entity<M>` wrapper used by the generic DataDriver API.
- *
- * @group DataDriver
- */
-export interface RestFetchService {
-    /**
-     * Fetch a collection of flattened entities with optional relation includes.
-     */
-    fetchCollectionForRest(collectionPath: string, options?: {
-        filter?: FilterValues<string>;
-        orderBy?: string;
-        order?: "desc" | "asc";
-        limit?: number;
-        offset?: number;
-        startAfter?: Record<string, unknown>;
-        searchString?: string;
-        databaseId?: string;
-        vectorSearch?: VectorSearchParams;
-    }, include?: string[]): Promise<Record<string, unknown>[]>;
-    /**
-     * Fetch a single flattened entity with optional relation includes.
-     */
-    fetchEntityForRest(collectionPath: string, entityId: string | number, include?: string[], databaseId?: string): Promise<Record<string, unknown> | null>;
-}

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

@@ -1,11 +0,0 @@
-/**
- * @module database_admin
- *
- * Re-exports the capability-specific admin interfaces from `@rebasepro/types/backend`.
- * This file is kept for backwards compatibility — new code should import from
- * `@rebasepro/types` directly.
- *
- * @group Admin
- */
-export type { SQLAdmin, DocumentAdmin, SchemaAdmin, DatabaseAdmin, HealthCheckResult } from "../types/backend";
-export { isSQLAdmin, isDocumentAdmin, isSchemaAdmin } from "../types/backend";

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

@@ -1,36 +0,0 @@
-import React from "react";
-/**
- * Controller to open the side dialog
- * @group Hooks and utilities
- */
-export interface DialogsController {
-    /**
-     * Close the last dialog
-     */
-    close: () => void;
-    /**
-     * Open a dialog
-     * @param props
-     */
-    open: <T extends object = object>(props: DialogControllerEntryProps<T>) => {
-        closeDialog: () => void;
-    };
-}
-/**
- * Props used to open a side dialog
- * @group Hooks and utilities
- */
-export interface DialogControllerEntryProps<T extends object = object> {
-    key: string;
-    /**
-     * The component type that will be rendered
-     */
-    Component: React.ComponentType<{
-        open: boolean;
-        closeDialog: () => void;
-    } & T>;
-    /**
-     * Props to pass to the dialog component
-     */
-    props?: T;
-}

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

@@ -1,4 +0,0 @@
-export interface EffectiveRoleController {
-    effectiveRole: string | null;
-    setEffectiveRole: (role: string | null) => void;
-}

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

@@ -1,36 +0,0 @@
-/**
- * Email service types — portable interface shared by RebaseClient and server-core.
- *
- * The concrete SMTP implementation lives in `@rebasepro/server-core/email`.
- * This file provides only the consumer-facing contract so that it can be
- * referenced from `RebaseClient` without dragging in nodemailer.
- */
-/**
- * Options for sending an email via the Rebase email service.
- */
-export interface EmailSendOptions {
-    /** Recipient email address(es). */
-    to: string | string[];
-    /** Email subject line. */
-    subject: string;
-    /** HTML body content. */
-    html: string;
-    /** Optional plain-text fallback. */
-    text?: string;
-    /** Optional reply-to address. */
-    replyTo?: string;
-}
-/**
- * Abstraction over an email delivery backend.
- *
- * Implementations may use SMTP, AWS SES, Resend, Postmark, or any other
- * provider — consumers only interact through this interface.
- */
-export interface EmailService {
-    /** Send a single email. */
-    send(options: EmailSendOptions): Promise<void>;
-    /** Returns `true` when the service has valid credentials / is ready to send. */
-    isConfigured(): boolean;
-    /** Verify connection/credentials with the email provider. */
-    verifyConnection?(): Promise<boolean>;
-}

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

@@ -1,18 +0,0 @@
-export * from "./collection_registry";
-export * from "./analytics_controller";
-export * from "./auth";
-export * from "./data";
-export * from "./database_admin";
-export * from "./data_driver";
-export * from "./local_config_persistence";
-export * from "./navigation";
-export * from "./effective_role";
-export * from "./storage";
-export * from "./email";
-export * from "./client";
-export * from "./customization_controller";
-export * from "./side_entity_controller";
-export * from "./side_dialogs_controller";
-export * from "./dialogs_controller";
-export * from "./snackbar";
-export * from "./registry";

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

@@ -1,20 +0,0 @@
-import type { EntityCollection } from "../types/collections";
-/**
- * @group Models
- */
-export type PartialEntityCollection<M extends Record<string, unknown> = Record<string, unknown>> = Partial<EntityCollection<M>>;
-/**
- * This interface is in charge of defining the controller that persists
- * modifications to a collection or collection, and retrieves them back from
- * a data source, such as local storage or Firestore.
- */
-export interface UserConfigurationPersistence {
-    onCollectionModified: <M extends Record<string, unknown> = Record<string, unknown>>(path: string, partialCollection: PartialEntityCollection<M>) => void;
-    getCollectionConfig: <M extends Record<string, unknown> = Record<string, unknown>>(path: string) => PartialEntityCollection<M>;
-    recentlyVisitedPaths: string[];
-    setRecentlyVisitedPaths: (paths: string[]) => void;
-    favouritePaths: string[];
-    setFavouritePaths: (paths: string[]) => void;
-    collapsedGroups: string[];
-    setCollapsedGroups: (paths: string[]) => void;
-}