@rebasepro/server-postgres 0.0.1-canary.4829d6e

package/dist/services/FetchService.d.ts

@@ -0,0 +1,214 @@
+import { SQL } from "drizzle-orm";
+import { PgTable } from "drizzle-orm/pg-core";
+import { FilterValues, LogicalCondition } from "@rebasepro/types";
+import type { VectorSearchParams } from "@rebasepro/types";
+import { RelationService } from "./RelationService";
+import { DrizzleClient } from "../interfaces";
+import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
+/**
+ * Service for handling all row read operations.
+ * Handles fetching, searching, counting, and filtering rows.
+ */
+export declare class FetchService {
+    private db;
+    private registry;
+    private relationService;
+    constructor(db: DrizzleClient, registry: PostgresCollectionRegistry);
+    /**
+     * Get the relational query builder for a given table name.
+     * Safely narrows the DrizzleClient union type to access db.query[tableName].
+     */
+    private getQueryBuilder;
+    /**
+     * Build filter conditions from FilterValues
+     * Delegates to DrizzleConditionBuilder.buildFilterConditions
+     */
+    buildFilterConditions<M extends Record<string, unknown>>(filter: FilterValues<Extract<keyof M, string>>, table: PgTable<any>, collectionPath: string): SQL[];
+    /**
+     * Resolves the correct Drizzle column for sorting.
+     * Automatically maps owning relation property keys to their underlying foreign key column.
+     */
+    private resolveOrderByField;
+    /**
+     * Build the `with` config for Drizzle's relational query API.
+     * Converts collection relations to a Drizzle-compatible `with` object.
+     *
+     * When `include` is provided, only those relations are loaded.
+     * When `include` is absent, ALL relations are loaded (CMS path).
+     *
+     * Automatically detects many-to-many junction tables and nests
+     * the target relation so actual row data is returned.
+     */
+    private buildWithConfig;
+    /**
+     * Detect if a many-to-many relation uses a junction table in the Drizzle schema.
+     */
+    private isJunctionRelation;
+    /**
+     * Get the Drizzle relation name on the junction table that points to the actual target row.
+     * For example, for posts_tags junction, this returns "tag_id" (the relation pointing to tags).
+     */
+    private getJunctionTargetRelationName;
+    /**
+     * Convert a db.query result row (with nested relation objects) to a flat row.
+     * Handles:
+     * - Placing `id` at the top level as a string
+     * - Type normalization (dates, numbers, NaN) via normalizeDbValues
+     * - Converting nested relation objects to { id, path, __type: "relation" } for CMS
+     * - Flattening junction-table many-to-many results
+     */
+    private drizzleResultToRow;
+    /**
+     * Post-fetch joinPath relations for a single flat row.
+     * joinPath relations cannot be expressed via Drizzle's `with` config,
+     * so they must be loaded separately after the primary query.
+     */
+    private resolveJoinPathRelations;
+    /**
+     * Post-fetch joinPath relations for a batch of flat rows.
+     * Uses batch fetching to avoid N+1 queries for list views.
+     */
+    private resolveJoinPathRelationsBatch;
+    /**
+     * Resolves joinPath relations for raw REST rows and directly injects them.
+     * Uses RelationService to query the database and maps results back to the flattened objects.
+     */
+    private resolveJoinPathRelationsBatchRest;
+    /**
+     * Convert a db.query result row to a flat REST-style object with populated relations.
+     */
+    private drizzleResultToRestRow;
+    /**
+     * Build db.query-compatible options from standard fetch options.
+     * Handles filter, search, orderBy, limit, and cursor-based pagination.
+     */
+    private buildDrizzleQueryOptions;
+    /**
+     * Extract cursor pagination conditions from startAfter options.
+     */
+    private buildCursorConditions;
+    /**
+     * Fetch a single row by ID
+     */
+    fetchOne<M extends Record<string, unknown>>(collectionPath: string, id: string | number, databaseId?: string): Promise<Record<string, unknown> | undefined>;
+    /**
+     * Unified method to fetch rows with optional search functionality
+     */
+    fetchRowsWithConditions<M extends Record<string, unknown>>(collectionPath: string, options?: {
+        filter?: FilterValues<Extract<keyof M, string>>;
+        orderBy?: string;
+        order?: "desc" | "asc";
+        limit?: number;
+        offset?: number;
+        startAfter?: Record<string, unknown>;
+        searchString?: string;
+        databaseId?: string;
+        vectorSearch?: VectorSearchParams;
+        logical?: LogicalCondition;
+    }): Promise<Record<string, unknown>[]>;
+    /**
+     * Fallback path used when db.query is unavailable.
+     * The primary path uses drizzleResultToRow which handles relation
+     * mapping without N+1 queries.
+     *
+     * Process raw database results into flat rows with relations.
+     */
+    private processRowResults;
+    /**
+     * Fetch a collection of rows
+     */
+    fetchCollection<M extends Record<string, unknown>>(collectionPath: string, options?: {
+        filter?: FilterValues<Extract<keyof M, string>>;
+        orderBy?: string;
+        order?: "desc" | "asc";
+        limit?: number;
+        offset?: number;
+        startAfter?: Record<string, unknown>;
+        searchString?: string;
+        databaseId?: string;
+        vectorSearch?: VectorSearchParams;
+    }): Promise<Record<string, unknown>[]>;
+    /**
+     * Search rows by text
+     */
+    searchRows<M extends Record<string, unknown>>(collectionPath: string, searchString: string, options?: {
+        filter?: FilterValues<Extract<keyof M, string>>;
+        orderBy?: string;
+        order?: "desc" | "asc";
+        limit?: number;
+        databaseId?: string;
+    }): Promise<Record<string, unknown>[]>;
+    /**
+     * Fetch collection from multi-segment path
+     */
+    private fetchCollectionFromPath;
+    /**
+     * Count rows in a collection
+     */
+    count<M extends Record<string, unknown>>(collectionPath: string, options?: {
+        filter?: FilterValues<Extract<keyof M, string>>;
+        searchString?: string;
+        databaseId?: string;
+    }): Promise<number>;
+    /**
+     * Count rows from multi-segment path
+     */
+    private countEntitiesFromPath;
+    /**
+     * Check if a field value is unique
+     */
+    checkUniqueField(collectionPath: string, fieldName: string, value: unknown, excludeEntityId?: string, _databaseId?: string): Promise<boolean>;
+    /**
+     * Get the RelationService instance for external use
+     */
+    getRelationService(): RelationService;
+    /**
+     * Fetch a collection of rows with optional relation includes.
+     * When `include` is provided, only the specified relations are populated
+     * with full row data (not just { id, path, __type }).
+     * When `include` is absent, no relation queries are made (fast path).
+     *
+     * @param include - Array of relation keys to populate, or ["*"] for all
+     */
+    fetchCollectionForRest<M extends Record<string, unknown>>(collectionPath: string, options?: {
+        filter?: FilterValues<Extract<keyof M, 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 row with optional relation includes for REST API.
+     */
+    fetchOneForRest<M extends Record<string, unknown>>(collectionPath: string, id: string | number, include?: string[], databaseId?: string): Promise<Record<string, unknown> | null>;
+    /**
+     * Fetch raw rows without any relation processing (for REST fast path)
+     */
+    private fetchRowsWithConditionsRaw;
+    /**
+     * Check if the Drizzle instance has the relational query API available
+     * for a given collection path.
+     * Note: Primary path now uses inline `getQueryBuilder()` checks.
+     */
+    private hasDrizzleQueryAPI;
+    /**
+     * Attempt to use Drizzle's relational query API (db.query.<table>.findMany)
+     * for efficient JOIN-based relation loading.
+     * Returns null if the API is not available or the query fails.
+     * Note: Primary path now uses `buildWithConfig` + `buildDrizzleQueryOptions`.
+     */
+    private fetchWithDrizzleQuery;
+    /**
+     * Fallback path used when db.query is unavailable.
+     * The primary path uses db.query.findMany with `with` config, which
+     * loads all relations in a single query.
+     *
+     * Batch fetch many-to-many related rows for multiple parent IDs.
+     * Groups results by parent ID to avoid N+1.
+     */
+    private batchFetchManyRelatedRows;
+}

package/dist/services/PersistService.d.ts

@@ -0,0 +1,39 @@
+import { RelationService } from "./RelationService";
+import { FetchService } from "./FetchService";
+import { DrizzleClient } from "../interfaces";
+import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
+/**
+ * Service for handling all row write operations.
+ * Handles saving, deleting, and updating rows.
+ */
+export declare class PersistService {
+    private db;
+    private registry;
+    private relationService;
+    private fetchService;
+    constructor(db: DrizzleClient, registry: PostgresCollectionRegistry);
+    /**
+     * Delete an row by ID
+     */
+    delete(collectionPath: string, id: string | number, _databaseId?: string): Promise<void>;
+    /**
+     * Delete all rows from a collection
+     */
+    deleteAll(collectionPath: string, _databaseId?: string): Promise<void>;
+    /**
+     * Save an row (create or update)
+     */
+    save<M extends Record<string, unknown>>(collectionPath: string, values: Partial<M>, id?: string | number, databaseId?: string): Promise<Record<string, unknown>>;
+    /**
+     * Get the RelationService instance for external use
+     */
+    getRelationService(): RelationService;
+    /**
+     * Get the FetchService instance for external use
+     */
+    getFetchService(): FetchService;
+    /**
+     * Translate raw PostgreSQL / Drizzle errors into user-friendly messages.
+     */
+    private toUserFriendlyError;
+}

package/dist/services/RelationService.d.ts

@@ -0,0 +1,109 @@
+import { DrizzleClient } from "../interfaces";
+import { CollectionConfig, FilterValues, Relation } from "@rebasepro/types";
+import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
+/**
+ * Service for handling all relation-related operations.
+ * Handles fetching, updating, and managing row relations.
+ */
+/**
+ * A related record resolved by {@link RelationService}: the target row's
+ * values plus the identity (`id`) and originating collection (`path`)
+ * needed to build relation references. Internal to the postgres driver —
+ * flattened to plain rows at the fetch-service boundary.
+ */
+export interface RelatedRow<M extends Record<string, unknown> = Record<string, unknown>> {
+    id: string | number;
+    path: string;
+    values: M;
+}
+export declare class RelationService {
+    private db;
+    private registry;
+    constructor(db: DrizzleClient, registry: PostgresCollectionRegistry);
+    /**
+     * Fetch rows related to a parent row through a specific relation
+     */
+    fetchRelatedEntities<M extends Record<string, unknown>>(parentCollectionPath: string, parentId: string | number, relationKey: string, options?: {
+        filter?: FilterValues<Extract<keyof M, string>>;
+        orderBy?: string;
+        order?: "desc" | "asc";
+        limit?: number;
+        startAfter?: Record<string, unknown>;
+        searchString?: string;
+        databaseId?: string;
+    }): Promise<RelatedRow<M>[]>;
+    /**
+     * Fetch rows using join paths for complex relations
+     */
+    fetchEntitiesUsingJoins<M extends Record<string, unknown>>(parentCollection: CollectionConfig, parentId: string | number, relation: Relation, options?: {
+        filter?: FilterValues<Extract<keyof M, string>>;
+        orderBy?: string;
+        order?: "desc" | "asc";
+        limit?: number;
+        startAfter?: Record<string, unknown>;
+        searchString?: string;
+        databaseId?: string;
+    }): Promise<RelatedRow<M>[]>;
+    /**
+     * Count related rows for a parent row
+     */
+    countRelatedEntities<M extends Record<string, unknown>>(parentCollectionPath: string, parentId: string | number, relationKey: string, options?: {
+        filter?: FilterValues<Extract<keyof M, string>>;
+        databaseId?: string;
+    }): Promise<number>;
+    /**
+     * Batch fetch related rows for multiple parent rows to avoid N+1 queries
+     */
+    batchFetchRelatedEntities(parentCollectionPath: string, parentIds: (string | number)[], _relationKey: string, relation: Relation): Promise<Map<string, RelatedRow<Record<string, unknown>>>>;
+    /**
+     * Batch fetch many-cardinality related rows for multiple parent rows.
+     * Returns a Map<parentId, RelatedRow[]> instead of Map<parentId, RelatedRow>.
+     * Uses a single SQL query with IN clause to avoid N+1.
+     */
+    batchFetchRelatedEntitiesMany(parentCollectionPath: string, parentIds: (string | number)[], _relationKey: string, relation: Relation): Promise<Map<string, RelatedRow<Record<string, unknown>>[]>>;
+    /**
+     * Update many-to-many and junction relations
+     */
+    updateRelationsUsingJoins<M extends Record<string, unknown>>(tx: DrizzleClient, collection: CollectionConfig, id: string | number, relationValues: Partial<M>): Promise<void>;
+    /**
+     * Update inverse relations (where FK is on the target table)
+     */
+    updateInverseRelations(tx: DrizzleClient, sourceCollection: CollectionConfig, sourceEntityId: string | number, inverseRelationUpdates: Array<{
+        relationKey: string;
+        relation: Relation;
+        newValue: unknown;
+        currentId?: string | number;
+    }>): Promise<void>;
+    /**
+     * Handle inverse relations with joinPath
+     */
+    private updateInverseJoinPathRelation;
+    /**
+     * Handle many-to-many inverse relation updates using junction tables
+     */
+    private updateManyToManyInverseRelation;
+    /**
+     * Update one-to-one relations that use joinPath
+     */
+    updateJoinPathOneToOneRelations(tx: DrizzleClient, parentCollection: CollectionConfig, parentId: string | number, updates: Array<{
+        relationKey: string;
+        relation: Relation;
+        newTargetId: string | number | null;
+    }>): Promise<void>;
+    /**
+     * Resolve joinPath write mapping for one-to-one relations
+     */
+    resolveJoinPathWriteMapping(parentCollection: CollectionConfig, relation: Relation): {
+        targetFKColName: string;
+        parentSourceColName: string;
+    };
+    /**
+     * Handle junction table creation for many-to-many path-based saves
+     */
+    handleJunctionTableCreation(tx: DrizzleClient, newEntityId: string | number, junctionTableInfo: {
+        parentCollection: CollectionConfig;
+        parentId: string | number;
+        relation: Relation;
+        relationKey: string;
+    }): Promise<void>;
+}

package/dist/services/cdc/CdcListener.d.ts

@@ -0,0 +1,54 @@
+/**
+ * A single database change captured by the CDC triggers and delivered over the
+ * `rebase_cdc` NOTIFY channel.
+ */
+export interface CdcChangeEvent {
+    schema: string;
+    table: string;
+    op: "INSERT" | "UPDATE" | "DELETE";
+    /**
+     * The changed tuple (NEW for insert/update, OLD for delete). May be a
+     * partial identity-only object when the full row overflowed the pg_notify
+     * size cap — see {@link truncated}.
+     */
+    row: Record<string, unknown>;
+    /** True when the row was reduced to its identity because it was too large to notify. */
+    truncated?: boolean;
+}
+/**
+ * Parse a `rebase_cdc` NOTIFY payload. Returns `null` for anything malformed so
+ * a single bad message can never crash the listener.
+ */
+export declare function parseCdcPayload(payload: string): CdcChangeEvent | null;
+/**
+ * Dedicated Postgres LISTEN client for database-level CDC.
+ *
+ * Mirrors the resilience of the RealtimeService cross-instance LISTEN client: a
+ * standalone `pg.Client` (outside the Drizzle pool) that stays connected, and
+ * transparently reconnects on error/disconnect. Each backend instance runs one,
+ * so every instance observes every committed change regardless of which
+ * instance (or external process) made the write.
+ */
+export declare class CdcListener {
+    private readonly connectionString;
+    private readonly onEvent;
+    private client?;
+    private running;
+    private reconnectTimer?;
+    private static readonly RECONNECT_DELAY_MS;
+    constructor(connectionString: string, onEvent: (event: CdcChangeEvent) => void | Promise<void>);
+    /**
+     * Connect and begin listening. Idempotent.
+     *
+     * The **initial** connection is validated synchronously: if it cannot be
+     * established (or `LISTEN` is refused), this rejects so callers — notably
+     * `REALTIME_CDC=auto` — can detect an unusable connection and fall back to
+     * app-level realtime. Once the initial connection succeeds, later drops
+     * self-heal via {@link scheduleReconnect}.
+     */
+    start(): Promise<void>;
+    /** Stop listening and release the connection. */
+    stop(): Promise<void>;
+    private connect;
+    private scheduleReconnect;
+}

package/dist/services/cdc/trigger-cdc.d.ts

@@ -0,0 +1,64 @@
+import type { RawSqlRunner } from "../../security/rls-enforcement";
+/**
+ * Trigger-based Change Data Capture (CDC).
+ *
+ * The preferred CDC source is the write-ahead log (logical replication), which
+ * — like Supabase Realtime — sees *every* commit regardless of how it was made.
+ * When logical replication is unavailable (managed Postgres without
+ * `wal_level=logical`, no replication privilege, no `REPLICA IDENTITY`), this
+ * trigger-based fallback provides the same guarantee at the row level:
+ *
+ *   AFTER INSERT/UPDATE/DELETE trigger  →  pg_notify('rebase_cdc', payload)
+ *
+ * A single dedicated LISTEN client per backend instance consumes the channel
+ * (see {@link CdcListener}) and feeds the change into the existing
+ * `RealtimeService.notifyUpdate` pipeline, so subscribers see the change no
+ * matter what wrote it — psql, a cron in another service, raw Drizzle/SQL, or
+ * the Studio SQL editor.
+ *
+ * Provisioning runs from the framework's own bootstrap as the owner (server)
+ * context, alongside the RLS role provisioning. It is idempotent.
+ */
+/** Postgres NOTIFY channel carrying database-level change events. */
+export declare const CDC_CHANNEL = "rebase_cdc";
+/** Schema-qualified name of the generic trigger function. */
+export declare const CDC_TRIGGER_FUNCTION = "rebase.rebase_cdc_notify";
+/** Name of the per-table trigger (unqualified — triggers are namespaced by table). */
+export declare const CDC_TRIGGER_NAME = "rebase_cdc_trigger";
+/**
+ * SQL that (re)creates the generic CDC trigger function. Safe to run repeatedly:
+ * `CREATE OR REPLACE` updates in place without dropping dependent triggers.
+ *
+ * The function emits `{ schema, table, op, row }`. The `row` is the full changed
+ * tuple (NEW for insert/update, OLD for delete) so the consumer can route it to
+ * a collection and extract the primary key. It is *not* trusted for delivery:
+ * the consumer marks the row invalidated and each subscriber re-reads it under
+ * its own RLS context, so a subscriber never receives a row it cannot read.
+ */
+export declare function buildCdcFunctionSql(): string;
+/**
+ * SQL that (re)attaches the CDC trigger to a single table. `DROP ... IF EXISTS`
+ * before `CREATE` keeps it idempotent and picks up any function signature change.
+ */
+export declare function buildCdcTriggerSql(schema: string, table: string): string;
+export interface CdcTableRef {
+    schema: string;
+    table: string;
+}
+export interface ProvisionResult {
+    /** Tables the trigger was successfully attached to. */
+    installed: CdcTableRef[];
+    /** Tables that could not be provisioned (e.g. not yet migrated), with the error. */
+    skipped: Array<CdcTableRef & {
+        reason: string;
+    }>;
+}
+/**
+ * Idempotently install the CDC trigger function and per-table triggers.
+ *
+ * Runs as the owner (server) connection at bootstrap. A table that does not yet
+ * exist in the database (schema drift) is skipped with a warning rather than
+ * aborting the whole install, so one un-migrated collection cannot disable CDC
+ * for the rest.
+ */
+export declare function provisionTriggerCdc(run: RawSqlRunner, tables: CdcTableRef[]): Promise<ProvisionResult>;

package/dist/services/collection-helpers.d.ts

@@ -0,0 +1,38 @@
+import { PgTable, AnyPgColumn } from "drizzle-orm/pg-core";
+import { CollectionConfig } from "@rebasepro/types";
+import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
+/**
+ * Shared helper functions for row operations.
+ * These are used by FetchService, PersistService, and RelationService.
+ *
+ * All functions that need collection/table lookups require an explicit
+ * `PostgresCollectionRegistry` instance — there is no global singleton.
+ */
+/**
+ * Interface for Drizzle column metadata introspection.
+ * Replaces unsafe `as Record<string, unknown>` double-cast chains.
+ */
+export interface DrizzleColumnMeta {
+    columnType?: string;
+    dataType?: string;
+    primary?: boolean;
+}
+/** Safely extract Drizzle column metadata from a column object. */
+export declare function getColumnMeta(col: AnyPgColumn): DrizzleColumnMeta;
+export declare function getCollectionByPath(collectionPath: string, registry: PostgresCollectionRegistry): CollectionConfig;
+export declare function getTableForCollection(collection: CollectionConfig, registry: PostgresCollectionRegistry): PgTable<any>;
+export declare function getPrimaryKeys(collection: CollectionConfig, registry: PostgresCollectionRegistry): {
+    fieldName: string;
+    type: "string" | "number";
+    isUUID?: boolean;
+}[];
+export declare function parseIdValues(idValue: string | number, primaryKeys: {
+    fieldName: string;
+    type: "string" | "number";
+    isUUID?: boolean;
+}[]): Record<string, string | number>;
+export declare function buildCompositeId(values: Record<string, unknown>, primaryKeys: {
+    fieldName: string;
+    type: "string" | "number";
+    isUUID?: boolean;
+}[]): string;

package/dist/services/dataService.d.ts

@@ -0,0 +1,110 @@
+import { FilterValues } from "@rebasepro/types";
+import type { VectorSearchParams } from "@rebasepro/types";
+import { FetchService } from "./FetchService";
+import { PersistService } from "./PersistService";
+import { RelationService } from "./RelationService";
+import { DataRepository, DrizzleClient } from "../interfaces";
+import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
+export { sanitizeAndConvertDates, serializeDataToServer, parseDataFromServer } from "../data-transformer";
+export { FetchService } from "./FetchService";
+export { PersistService } from "./PersistService";
+export { RelationService } from "./RelationService";
+export * from "../interfaces";
+/**
+ * DataService - Facade for row operations.
+ *
+ * This class provides a unified API for row CRUD operations by delegating
+ * to specialized services:
+ * - FetchService: Read operations (fetch, search, count)
+ * - PersistService: Write operations (save, delete)
+ * - RelationService: Relation operations (fetch related, update relations)
+ *
+ * Implements the DataRepository interface for database abstraction.
+ */
+export declare class DataService implements DataRepository {
+    private db;
+    private registry;
+    private fetchService;
+    private persistService;
+    constructor(db: DrizzleClient, registry: PostgresCollectionRegistry);
+    /**
+     * Fetch a single row by ID
+     */
+    fetchOne<M extends Record<string, unknown>>(collectionPath: string, id: string | number, databaseId?: string): Promise<Record<string, unknown> | undefined>;
+    /**
+     * Fetch a collection of rows with optional filtering, ordering, and pagination
+     */
+    fetchCollection<M extends Record<string, unknown>>(collectionPath: string, options?: {
+        filter?: FilterValues<Extract<keyof M, string>>;
+        orderBy?: string;
+        order?: "desc" | "asc";
+        limit?: number;
+        offset?: number;
+        startAfter?: Record<string, unknown>;
+        searchString?: string;
+        databaseId?: string;
+        vectorSearch?: VectorSearchParams;
+    }): Promise<Record<string, unknown>[]>;
+    /**
+     * Search rows by text
+     */
+    searchRows<M extends Record<string, unknown>>(collectionPath: string, searchString: string, options?: {
+        filter?: FilterValues<Extract<keyof M, string>>;
+        orderBy?: string;
+        order?: "desc" | "asc";
+        limit?: number;
+        databaseId?: string;
+    }): Promise<Record<string, unknown>[]>;
+    /**
+     * Count rows in a collection
+     */
+    count<M extends Record<string, unknown>>(collectionPath: string, options?: {
+        filter?: FilterValues<Extract<keyof M, string>>;
+        searchString?: string;
+        databaseId?: string;
+    }): Promise<number>;
+    /**
+     * Check if a field value is unique in a collection
+     */
+    checkUniqueField(collectionPath: string, fieldName: string, value: unknown, excludeEntityId?: string, databaseId?: string): Promise<boolean>;
+    /**
+     * Fetch rows related to a parent row
+     */
+    fetchRelatedEntities<M extends Record<string, unknown>>(parentCollectionPath: string, parentId: string | number, relationKey: string, options?: {
+        filter?: FilterValues<Extract<keyof M, string>>;
+        orderBy?: string;
+        order?: "desc" | "asc";
+        limit?: number;
+        startAfter?: Record<string, unknown>;
+        searchString?: string;
+        databaseId?: string;
+    }): Promise<Record<string, unknown>[]>;
+    /**
+     * Save an row (create or update)
+     */
+    save<M extends Record<string, unknown>>(collectionPath: string, values: Partial<M>, id?: string | number, databaseId?: string): Promise<Record<string, unknown>>;
+    /**
+     * Delete an row by ID
+     */
+    delete(collectionPath: string, id: string | number, databaseId?: string): Promise<void>;
+    /**
+     * Delete all rows from a collection
+     */
+    deleteAll(collectionPath: string, databaseId?: string): Promise<void>;
+    /**
+     * Execute raw SQL
+     */
+    executeSql(sqlText: string, params?: unknown[]): Promise<Record<string, unknown>[]>;
+    /**
+     * Get the underlying FetchService for advanced use
+     */
+    getFetchService(): FetchService;
+    /**
+     * Get the underlying PersistService for advanced use
+     */
+    getPersistService(): PersistService;
+    /**
+     * Get the underlying RelationService for advanced use
+     */
+    getRelationService(): RelationService;
+}

package/dist/services/index.d.ts

@@ -0,0 +1,4 @@
+export { FetchService } from "./FetchService";
+export { PersistService } from "./PersistService";
+export { RelationService } from "./RelationService";
+export { getCollectionByPath, getTableForCollection, getPrimaryKeys, parseIdValues, buildCompositeId } from "./collection-helpers";