@rebasepro/server-postgres 0.17.3 → 0.18.1

package/src/services/collection-helpers.ts

@@ -1,420 +0,0 @@
-import { PgTable, AnyPgColumn } from "drizzle-orm/pg-core";
-import { getTableColumns } from "drizzle-orm";
-import { CollectionConfig, Property, ResolvedHasMany, ResolvedHasOne } from "@rebasepro/types";
-import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
-import { fieldKeyForColumn, getTableName } from "@rebasepro/common";
-import { ApiError, logger } from "@rebasepro/server";
-
-// Row identity is derived on both sides of the wire — the driver parses an
-// incoming address into key columns, the admin derives one from a served row —
-// so the implementation lives in `common` and both agree by construction.
-export { buildCompositeId, parseIdValues, isAddressableId, COMPOSITE_ID_SEPARATOR } from "@rebasepro/common";
-export type { PrimaryKeyInfo } from "@rebasepro/common";
-import { buildCompositeId, COMPOSITE_ID_SEPARATOR, getDeclaredPrimaryKeys, isAddressableId } from "@rebasepro/common";
-import type { PrimaryKeyInfo } from "@rebasepro/common";
-
-/**
- * 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 function getColumnMeta(col: AnyPgColumn): DrizzleColumnMeta {
-    const raw = col as unknown as Record<string | symbol, unknown>;
-    return {
-        columnType: typeof raw.columnType === "string" ? raw.columnType : undefined,
-        dataType: typeof raw.dataType === "string" ? raw.dataType : undefined,
-        primary: typeof raw.primary === "boolean" ? raw.primary : undefined
-    };
-}
-
-/**
- * Whether an address could name a row in this table, judged by the columns.
- *
- * {@link getPrimaryKeys} lets a config's `isId: "uuid"` win over the schema, so
- * its `isUUID` is a claim rather than a fact — right for deriving addresses,
- * wrong for refusing a query. Here the Drizzle column type decides, because it
- * is what Postgres will enforce: a `uuid` column meets `/c/products/new` with
- * `22P02`, which aborts the surrounding transaction and turns every later
- * statement into an unrelated-looking `25P02`.
- */
-export function idCanAddressTable(
-    id: string | number,
-    table: PgTable,
-    idInfoArray: PrimaryKeyInfo[]
-): boolean {
-    const columnBacked = idInfoArray.map(info => {
-        const col = table[info.fieldName as keyof typeof table] as AnyPgColumn | undefined;
-        const meta = col ? getColumnMeta(col) : undefined;
-        // No column to ask (a key the schema does not carry) leaves the id
-        // addressable: refusing on a guess would 404 rows that do exist.
-        if (!meta?.columnType) return info;
-        return { ...info,
-            isUUID: meta.columnType === "PgUUID" };
-    });
-    return isAddressableId(id, columnBacked);
-}
-
-export function getCollectionByPath(collectionPath: string, registry: PostgresCollectionRegistry): CollectionConfig {
-    const collection = registry.getCollectionByPath(collectionPath);
-    if (!collection) {
-        const registered = registry.getCollections().map(c => c.slug).join(", ");
-        throw new Error(`Collection not found: ${collectionPath}. Registered collections: [${registered}]`);
-    }
-    return collection;
-}
-
-/**
- * Reject a write naming something that is not a column of the table.
- *
- * Drizzle builds INSERT from `Object.entries(table[Symbol.Columns])` and UPDATE
- * from `Object.keys(tableColumns)`, so a key the table does not carry is not
- * rejected by anything — it is *left out of the statement*. The insert answers
- * 201 having stored nothing under that name; the update, if the key was the
- * only one, builds `update "posts" set  where …` and Postgres raises a syntax
- * error (SQLSTATE 42601), which is neither class 22 nor 23 and so surfaces as a
- * 500 for what is a caller's typo.
- *
- * That makes this the last honest place to check, and the only one every write
- * passes through. `assertKnownWriteFields` in the REST layer checks the same
- * thing against the *config* and is skipped on four paths — `strictWrites:
- * false`, a collection declaring no properties, an auth adapter that owns the
- * body's shape, and a nested route whose target cannot be walked — and it never
- * sees an in-process `rebase.data` write at all.
- *
- * It also gives `strictWrites: false` a truthful implementation. The flag is
- * documented for "a column that really does exist which the config never
- * declared", and skipping the config check alone could not deliver that: the
- * value was dropped a layer later regardless. Skipping the config check and
- * keeping this one does exactly what the flag says — the column must exist,
- * the property need not.
- */
-export function assertWritableColumns(
-    values: Record<string, unknown>,
-    table: PgTable,
-    collectionPath: string
-): void {
-    // Only a real Drizzle table carries a column list. A stand-in that does not
-    // (a test double, a registry entry built by hand) has nothing to check
-    // against, and inventing an answer from its own keys would reject writes
-    // over the shape of the double rather than the shape of the table.
-    const columns = getTableColumns(table) as Record<string, unknown> | undefined;
-    if (!columns || Object.keys(columns).length === 0) return;
-
-    const unknown = Object.keys(values).filter(key => !(key in columns));
-    if (unknown.length === 0) return;
-
-    // The offending keys, and deliberately not the list of real ones: this
-    // error is reachable on paths where the REST field check was skipped, and
-    // an `excludeFromApi` column is documented as never being served to a
-    // caller. Naming what was sent is the actionable half anyway.
-    throw ApiError.badRequest(
-        `'${collectionPath}' has no column${unknown.length > 1 ? "s" : ""} ` +
-        `${unknown.map(key => `'${key}'`).join(", ")}, so the value${unknown.length > 1 ? "s" : ""} ` +
-        "would have been dropped before the statement was built.",
-        "VALIDATION_UNKNOWN_FIELDS"
-    );
-}
-
-/**
- * A relation whose names do not resolve against the registered schema.
- *
- * Every one of these used to be a `logger.warn` followed by `continue`, so a
- * save reported success for a relation it had not written and a read answered
- * `[]` for one it could not resolve. `assertRelationsResolve` (validate-relations)
- * fails boot on the same defects, which is where they belong — a server that
- * refuses to start is recoverable in a minute. This is the second line, for the
- * paths that assemble a registry by hand, and it exists so that "cannot resolve"
- * is never again reported as "done".
- *
- * @param label  `<collection>.<relation>`
- * @param detail what does not resolve, in terms of the schema
- */
-export function relationMisconfigured(label: string, detail: string): ApiError {
-    return ApiError.internal(
-        `Relation '${label}' does not resolve against the registered schema: ${detail}. ` +
-        "The operation was refused rather than skipped — silently dropping it would report " +
-        "success for a write that never happened, or emptiness for rows that exist. Run " +
-        "`rebase schema generate` if the generated schema is older than the database.",
-        "RELATION_MISCONFIGURED"
-    );
-}
-
-export function getTableForCollection(collection: CollectionConfig, registry: PostgresCollectionRegistry): PgTable<any> {
-    const tableName = getTableName(collection);
-    const table = registry.getTable(tableName);
-    if (!table) {
-        throw new Error(`Table not found for collection '${collection.slug}' (table: ${tableName})`);
-    }
-    return table;
-}
-
-/**
- * The key columns a collection's rows are addressed by.
- *
- * Three tiers, in order: properties marked `isId`, the primary keys of the
- * drizzle schema, and finally a column literally named `id`. Only the first is
- * visible to the browser, which is why a key known only to drizzle is reported
- * at boot — see {@link warnOnKeysTheAdminCannotResolve}.
- *
- * Returns `[]` when nothing resolves, rather than throwing. It used to open by
- * resolving the table, which throws when there is none — so the `isId` tier,
- * which needs no table at all, was unreachable for exactly the collections
- * most likely to have no table registered. Every caller that wanted "no keys"
- * to mean "no keys" had to spell that out in a try/catch.
- *
- * Callers that cannot proceed without a key must say so themselves, naming the
- * collection: an empty array here means "this collection has no address", which
- * is a different answer in a notification (broadcast a wildcard) than in a save
- * (fail).
- */
-export function getPrimaryKeys(collection: CollectionConfig, registry: PostgresCollectionRegistry): PrimaryKeyInfo[] {
-    // Explicitly declared `isId` properties win, and need no table.
-    if (collection.properties) {
-        const idProps = Object.entries(collection.properties)
-            .filter(([_, prop]) => "isId" in (prop as object) && Boolean((prop as { isId?: unknown }).isId))
-            .map(([key, prop]) => ({
-                fieldName: key,
-                type: prop.type === "number" ? "number" as const : "string" as const,
-                isUUID: (prop as { isId?: unknown }).isId === "uuid"
-            }));
-
-        if (idProps.length > 0) {
-            return idProps;
-        }
-    }
-
-    // The remaining tiers read the drizzle schema, so they need the table. A
-    // collection without one — another engine's, or simply unregistered — has
-    // nothing more to offer.
-    const table = registry.getTable(getTableName(collection));
-    if (!table) return [];
-
-    // Otherwise infer from Drizzle schema
-    const keys: PrimaryKeyInfo[] = [];
-    for (const [key, colRaw] of Object.entries(table)) {
-        const col = colRaw as AnyPgColumn;
-        if (col && typeof col === "object" && "primary" in col && col.primary) {
-            const meta = getColumnMeta(col);
-            const type = col.dataType === "number" || meta.columnType === "PgSerial" || meta.columnType === "PgInteger" ? "number" : "string";
-            const isUUID = meta.columnType === "PgUUID";
-            keys.push({ fieldName: key,
-type,
-isUUID });
-        }
-    }
-
-    // A collection that declares no primary key gets the implicit `id` column,
-    // which is what the schema generators emit for it — so read it back the
-    // same way rather than reporting the table as keyless.
-    if (keys.length === 0 && "id" in table) {
-        const idCol = table["id" as keyof typeof table] as AnyPgColumn;
-        const idMeta = getColumnMeta(idCol);
-        const type = idCol.dataType === "number" || idMeta.columnType === "PgSerial" || idMeta.columnType === "PgInteger" ? "number" : "string";
-        const isUUID = idMeta.columnType === "PgUUID";
-        keys.push({ fieldName: "id",
-type,
-isUUID });
-    }
-
-    return keys;
-}
-
-/**
- * The key columns, for callers that cannot do their job without one.
- *
- * {@link getPrimaryKeys} answers "what keys, if any" and returns `[]` for a
- * collection with no address. Most of this driver, though, is building a WHERE
- * clause and has no meaning without a key — for those, an empty array is not an
- * answer, and indexing `[0]` into it produces `Cannot read properties of
- * undefined` three frames from where the real problem is. This says what is
- * wrong and which collection it is wrong about.
- */
-export function requirePrimaryKeys(collection: CollectionConfig, registry: PostgresCollectionRegistry): PrimaryKeyInfo[] {
-    const keys = getPrimaryKeys(collection, registry);
-    if (keys.length === 0) {
-        throw new Error(
-            `Collection '${collection.slug}' has no primary key, so its rows cannot be addressed. ` +
-            `Mark the key property with \`isId\` in its config, or register a table whose schema declares one.`
-        );
-    }
-    return keys;
-}
-
-/**
- * The column on the *source* table that a `hasOne`/`hasMany` link points at.
- *
- * `sourceKey` is authored when the two sides join on a natural key — an
- * external identity id, a SKU — and left off when they join on the row id,
- * which is the overwhelming majority. That makes `undefined` the only optional
- * field on a resolved relation, so it gets exactly one reader: this function.
- * Every consumer that needs the column asks here, and none of them re-derives
- * "or else the primary key" for itself. That is the whole point — the fallback
- * chains this codebase removed from relation resolution were dangerous because
- * they were *duplicated* and could disagree, not because they existed.
- */
-export function sourceKeyField(
-    relation: ResolvedHasOne | ResolvedHasMany,
-    sourceCollection: CollectionConfig,
-    registry: PostgresCollectionRegistry
-): string {
-    // A **field**, as the name says: callers index the Drizzle table and the
-    // rows it returns with what comes back from here, and both are keyed by the
-    // wire name. `sourceKey` is authored in *column* terms, like every other
-    // link on a relation, so it is translated here rather than at each of the
-    // call sites — where it used to be `tenant_id` looked up on a table whose
-    // key is `tenantId`, finding nothing.
-    if (relation.sourceKey) return fieldKeyForColumn(sourceCollection, relation.sourceKey);
-    return requirePrimaryKeys(sourceCollection, registry)[0].fieldName;
-}
-
-/**
- * Whether this link joins on something other than the source's primary key.
- *
- * Callers that hold a parent *id* — which is most of them, since an id is what
- * a URL carries — must translate it to the source key's value before it can be
- * compared with the target's foreign key. Those that hold the parent *row*, or
- * that build a correlated subquery over the source table, can read the column
- * directly and skip the lookup.
- */
-export function joinsOnNaturalKey(
-    relation: ResolvedHasOne | ResolvedHasMany,
-    sourceCollection: CollectionConfig,
-    registry: PostgresCollectionRegistry
-): boolean {
-    if (!relation.sourceKey) return false;
-    // Compared as fields, because the right-hand side is one.
-    return fieldKeyForColumn(sourceCollection, relation.sourceKey)
-        !== requirePrimaryKeys(sourceCollection, registry)[0].fieldName;
-}
-
-/**
- * Collections whose key the *browser* cannot resolve, and what it will do
- * instead.
- *
- * The two sides resolve keys from different evidence. This driver reads, in
- * order: properties marked `isId`, the primary keys of the Drizzle schema, then
- * a column literally named `id`. The admin shares the `CollectionConfig` — it
- * compiles the same collection files into its bundle — but never the Drizzle
- * schema, so the middle tier is invisible to it.
- *
- * Nothing can normalize this at runtime: the server does not serve the admin
- * its collections, so a key resolved here cannot be handed over there. The
- * config files are the only thing both sides read, so the fix is an edit to
- * them, and the most this can do is say exactly which edit.
- *
- * Two shapes, and the second is the dangerous one:
- *
- * - No `isId`, no `id` property → the admin resolves no address, warns in the
- *   console, and rows cannot be opened or linked.
- * - No `isId`, but an `id` property that is *not* the key → the admin addresses
- *   rows by `id` while this driver reads the address as the real key. Nothing
- *   errors: the addresses look right and route wrong.
- */
-export function findUnresolvableKeyCollections(
-    collections: CollectionConfig[],
-    registry: PostgresCollectionRegistry
-): { collection: CollectionConfig; keys: PrimaryKeyInfo[]; shadowedByIdProperty: boolean }[] {
-    const findings: { collection: CollectionConfig; keys: PrimaryKeyInfo[]; shadowedByIdProperty: boolean }[] = [];
-
-    for (const collection of collections) {
-        // Declared `isId` is the tier both sides share: if it is there, they agree.
-        if (getDeclaredPrimaryKeys(collection).length > 0) continue;
-
-        // No registered table resolves to no keys, and a collection this cannot
-        // resolve a key for is one it has nothing to say about.
-        const keys = getPrimaryKeys(collection, registry);
-        if (keys.length === 0) continue;
-
-        // A single key named `id` is the last tier on both sides: they agree
-        // without anything being declared.
-        if (keys.length === 1 && keys[0].fieldName === "id") continue;
-
-        findings.push({
-            collection,
-            keys,
-            shadowedByIdProperty: Boolean(collection.properties?.id)
-        });
-    }
-
-    return findings;
-}
-
-/**
- * Report the collections from {@link findUnresolvableKeyCollections} at boot,
- * with the edit that fixes each one.
- *
- * Grouped by failure, not by collection: the shadowed case is a routing bug and
- * the silent case is a missing feature, and they deserve different urgency.
- */
-export function warnOnKeysTheAdminCannotResolve(
-    collections: CollectionConfig[],
-    registry: PostgresCollectionRegistry
-): void {
-    const findings = findUnresolvableKeyCollections(collections, registry);
-    if (findings.length === 0) return;
-
-    const edit = (f: { collection: CollectionConfig; keys: PrimaryKeyInfo[] }) =>
-        `${f.collection.slug}: mark ${f.keys.map(k => `\`${k.fieldName}\``).join(" and ")} with ` +
-        `\`isId: ${f.keys[0].isUUID ? "\"uuid\"" : f.keys[0].type === "number" ? "\"increment\"" : "true"}\``;
-
-    const shadowed = findings.filter(f => f.shadowedByIdProperty);
-    const silent = findings.filter(f => !f.shadowedByIdProperty);
-
-    if (shadowed.length > 0) {
-        logger.warn(
-            `⚠️ These collections declare no \`isId\`, and their key is only in the drizzle schema — but they ` +
-            `do have a property called \`id\`. The admin has no way to know \`id\` is not the key, so it will ` +
-            `address rows by it while this server reads the address as the real key: the links look right and ` +
-            `route wrong. Nothing will error.\n\n` +
-            shadowed.map(f => `  • ${edit(f)}`).join("\n") + "\n"
-        );
-    }
-
-    if (silent.length > 0) {
-        logger.warn(
-            `⚠️ These collections declare no \`isId\`, and their key is only in the drizzle schema, which the ` +
-            `admin never sees. It will resolve no address for their rows, so detail links, caching and ` +
-            `relations will not work for them:\n\n` +
-            silent.map(f => `  • ${edit(f)}`).join("\n") + "\n"
-        );
-    }
-}
-
-/**
- * The address of a row: derived from the collection's primary keys, because a
- * row does not carry one — it is exactly its columns.
- *
- * Falls back to a literal `id` column, for a row that reached us from somewhere
- * other than this driver. Returns `""` when there is no key and no `id` —
- * callers decide what that means, since "unaddressable" is a different answer
- * in a notification (broadcast a wildcard) than in a save (fail).
- */
-export function deriveRowAddress(
-    row: Record<string, unknown>,
-    collection: CollectionConfig,
-    registry: PostgresCollectionRegistry
-): string {
-    const composite = buildCompositeId(row, getPrimaryKeys(collection, registry));
-    // An all-empty composite is indistinguishable from a missing key, and
-    // `buildCompositeId` returns "" for no keys at all.
-    if (composite && composite.split(COMPOSITE_ID_SEPARATOR).some(part => part !== "")) {
-        return composite;
-    }
-    if (row.id !== undefined && row.id !== null) return String(row.id);
-    return "";
-}
-

package/src/services/dataService.ts

@@ -1,256 +0,0 @@
-// import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { FilterValues, LogicalCondition, OrderByTuple } from "@rebasepro/types";
-import type { VectorSearchParams } from "@rebasepro/types";
-import { FetchService } from "./FetchService";
-import { PersistService } from "./PersistService";
-import { RelationService } from "./RelationService";
-import { DataRepository, FetchCollectionOptions, SearchOptions, CountOptions, DrizzleClient } from "../interfaces";
-import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
-
-// Re-export data transformer functions for external use
-export { sanitizeAndConvertDates, serializeDataToServer, parseDataFromServer } from "../data-transformer";
-
-// Re-export service classes for direct use
-export { FetchService } from "./FetchService";
-export { PersistService } from "./PersistService";
-export { RelationService } from "./RelationService";
-
-// Re-export interfaces
-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 class DataService implements DataRepository {
-    private fetchService: FetchService;
-    private persistService: PersistService;
-
-    constructor(private db: DrizzleClient, private registry: PostgresCollectionRegistry) {
-        this.fetchService = new FetchService(db, registry);
-        this.persistService = new PersistService(db, registry);
-    }
-
-    // =============================================================
-    // READ OPERATIONS - Delegated to FetchService
-    // =============================================================
-
-    /**
-     * Fetch a single row by ID
-     */
-    async fetchOne<M extends Record<string, unknown>>(
-        collectionPath: string,
-        id: string | number,
-        databaseId?: string
-    ): Promise<Record<string, unknown> | undefined> {
-        return this.fetchService.fetchOne<M>(collectionPath, id, databaseId);
-    }
-
-    /**
-     * Fetch a collection of rows with optional filtering, ordering, and pagination
-     */
-    async fetchCollection<M extends Record<string, unknown>>(
-        collectionPath: string,
-        options: {
-            filter?: FilterValues<Extract<keyof M, string>>;
-            /** An `or(...)`/`and(...)` group, applied alongside `filter`. */
-            logical?: LogicalCondition;
-            orderBy?: string | OrderByTuple[];
-            order?: "desc" | "asc";
-            limit?: number;
-            offset?: number;
-            startAfter?: Record<string, unknown>;
-            searchString?: string;
-            databaseId?: string;
-            vectorSearch?: VectorSearchParams;
-        } = {}
-    ): Promise<Record<string, unknown>[]> {
-        return this.fetchService.fetchCollection<M>(collectionPath, options);
-    }
-
-    /**
-     * Search rows by text
-     */
-    async searchRows<M extends Record<string, unknown>>(
-        collectionPath: string,
-        searchString: string,
-        options: {
-            filter?: FilterValues<Extract<keyof M, string>>;
-            /** An `or(...)`/`and(...)` group, applied alongside `filter`. */
-            logical?: LogicalCondition;
-            orderBy?: string | OrderByTuple[];
-            order?: "desc" | "asc";
-            limit?: number;
-            databaseId?: string;
-            searchExplain?: boolean;
-        } = {}
-    ): Promise<Record<string, unknown>[]> {
-        return this.fetchService.searchRows<M>(collectionPath, searchString, options);
-    }
-
-    /**
-     * Count rows in a collection
-     */
-    async count<M extends Record<string, unknown>>(
-        collectionPath: string,
-        options: {
-            filter?: FilterValues<Extract<keyof M, string>>;
-            /** An `or(...)`/`and(...)` group, applied alongside `filter`. */
-            logical?: LogicalCondition;
-            searchString?: string;
-            databaseId?: string;
-            /** Only the `threshold` narrows the count — see `FetchService.count`. */
-            vectorSearch?: VectorSearchParams;
-        } = {}
-    ): Promise<number> {
-        return this.fetchService.count<M>(collectionPath, options);
-    }
-
-    /**
-     * Check if a field value is unique in a collection
-     */
-    async checkUniqueField(
-        collectionPath: string,
-        fieldName: string,
-        value: unknown,
-        excludeEntityId?: string,
-        databaseId?: string
-    ): Promise<boolean> {
-        return this.fetchService.checkUniqueField(collectionPath, fieldName, value, excludeEntityId, databaseId);
-    }
-
-    /**
-     * Fetch rows related to a parent row
-     */
-    async fetchRelatedEntities<M extends Record<string, unknown>>(
-        parentCollectionPath: string,
-        parentId: string | number,
-        relationKey: string,
-        options: {
-            filter?: FilterValues<Extract<keyof M, string>>;
-            orderBy?: string | OrderByTuple[];
-            order?: "desc" | "asc";
-            limit?: number;
-            startAfter?: Record<string, unknown>;
-            searchString?: string;
-            databaseId?: string;
-        } = {}
-    ): Promise<Record<string, unknown>[]> {
-        const rows = await this.fetchService.getRelationService().fetchRelatedEntities<M>(
-            parentCollectionPath,
-            parentId,
-            relationKey,
-            options
-        );
-        return rows.map(e => ({ ...e.values, id: e.id }));
-    }
-
-    // =============================================================
-    // WRITE OPERATIONS - Delegated to PersistService
-    // =============================================================
-
-    /**
-     * Save an row (create or update)
-     */
-    async save<M extends Record<string, unknown>>(
-        collectionPath: string,
-        values: Partial<M>,
-        id?: string | number,
-        databaseId?: string,
-        options?: { upsert?: boolean }
-    ): Promise<Record<string, unknown>> {
-        return this.persistService.save<M>(collectionPath, values, id, databaseId, options);
-    }
-
-    /**
-     * Delete an row by ID
-     */
-    async delete(
-        collectionPath: string,
-        id: string | number,
-        databaseId?: string
-    ): Promise<void> {
-        return this.persistService.delete(collectionPath, id, databaseId);
-    }
-
-    /**
-     * Delete all rows from a collection
-     */
-    async deleteAll(collectionPath: string, databaseId?: string): Promise<void> {
-        return this.persistService.deleteAll(collectionPath, databaseId);
-    }
-
-
-    /**
-     * Execute raw SQL
-     */
-    async executeSql(sqlText: string, params?: unknown[]): Promise<Record<string, unknown>[]> {
-        if (process.env.NODE_ENV !== "production") {
-            console.debug("Executing raw SQL:", sqlText, params?.length ? `with ${params.length} params` : "");
-        }
-        const { sql } = await import("drizzle-orm");
-
-        let result;
-        if (params && params.length > 0) {
-            // Build a parameterized query using Drizzle's sql tagged template.
-            // Split the SQL text on $1, $2, … placeholders and interleave
-            // with sql.param() calls so the underlying pg driver binds them safely.
-            const parts = sqlText.split(/\$(\d+)/);
-            const chunks: ReturnType<typeof sql.raw | typeof sql.param>[] = [];
-            for (let i = 0; i < parts.length; i++) {
-                if (i % 2 === 0) {
-                    // Literal SQL text fragment
-                    if (parts[i].length > 0) {
-                        chunks.push(sql.raw(parts[i]));
-                    }
-                } else {
-                    // Parameter reference — $N (1-indexed)
-                    const paramIndex = Number(parts[i]) - 1;
-                    chunks.push(sql.param(params[paramIndex]));
-                }
-            }
-            const query = sql.join(chunks, sql.raw(""));
-            result = await this.db.execute(query);
-        } else {
-            result = await this.db.execute(sql.raw(sqlText));
-        }
-
-        const rows = result.rows;
-        if (process.env.NODE_ENV !== "production") {
-            console.debug(`SQL executed successfully. Returned ${Array.isArray(rows) ? rows.length : "non-array"} rows.`);
-        }
-        return rows as Record<string, unknown>[];
-    }
-
-    // =============================================================
-    // SERVICE ACCESSORS
-    // =============================================================
-
-    /**
-     * Get the underlying FetchService for advanced use
-     */
-    getFetchService(): FetchService {
-        return this.fetchService;
-    }
-
-    /**
-     * Get the underlying PersistService for advanced use
-     */
-    getPersistService(): PersistService {
-        return this.persistService;
-    }
-
-    /**
-     * Get the underlying RelationService for advanced use
-     */
-    getRelationService(): RelationService {
-        return this.fetchService.getRelationService();
-    }
-}

package/src/services/index.ts

@@ -1,14 +0,0 @@
-// Re-export all service classes
-export { FetchService } from "./FetchService";
-export { PersistService } from "./PersistService";
-export { RelationService } from "./RelationService";
-
-// Re-export helper functions
-export {
-    getCollectionByPath,
-    getTableForCollection,
-    getPrimaryKeys,
-    deriveRowAddress,
-    parseIdValues,
-    buildCompositeId
-} from "./collection-helpers";