@rebasepro/server-core 0.0.1-canary.4d4fb3e

package/src/api/rest/api-generator.ts

@@ -0,0 +1,466 @@
+import { Hono } from "hono";
+import { DataDriver, Entity, EntityCollection, FetchCollectionProps } from "@rebasepro/types";
+import { QueryOptions, HonoEnv } from "../types";
+import { ApiError } from "../errors";
+import { parseQueryOptions } from "./query-parser";
+
+
+/**
+ * Lightweight REST API generator that leverages existing Rebase DataDriver.
+ * Supports `include` query parameter for eager-loading relations via Drizzle.
+ */
+export class RestApiGenerator {
+    private collections: EntityCollection[];
+    private router: Hono<HonoEnv>;
+    private driver: DataDriver;
+
+    constructor(collections: EntityCollection[], driver: DataDriver) {
+        this.collections = collections;
+        this.driver = driver;
+        this.router = new Hono<HonoEnv>();
+    }
+
+    /**
+     * Generate REST routes using existing DataDriver
+     */
+    generateRoutes(): Hono<HonoEnv> {
+        this.collections.forEach(collection => {
+            this.createCollectionRoutes(collection);
+        });
+
+        // Catch-all routes for subcollection paths like
+        // /authors/111094/posts  and  /authors/111094/posts/43
+        // The DataDriver already knows how to resolve nested relation paths.
+        this.createSubcollectionRoutes();
+
+        return this.router;
+    }
+
+    /**
+     * Get the EntityFetchService from a driver if it exposes one (for include support)
+     */
+    private getFetchService(driver: DataDriver): Record<string, (...args: unknown[]) => unknown> | null {
+        if ("entityService" in driver && typeof driver.entityService === "object" && driver.entityService) {
+            const es = driver.entityService as Record<string, unknown>;
+            if (typeof es.getFetchService === "function") {
+                return es.getFetchService();
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Create REST routes for a collection using existing Rebase patterns
+     */
+    private createCollectionRoutes(collection: EntityCollection): void {
+        const basePath = `/${collection.slug}`;
+        const resolvedCollection = collection;
+
+        // GET /collection - List entities
+        this.router.get(basePath, async (c) => {
+            const queryDict = c.req.query();
+            const queryOptions = parseQueryOptions(queryDict);
+
+            const driver = c.get("driver") || this.driver;
+            const fetchService = this.getFetchService(driver);
+
+            // Use include-aware path when available
+            if (fetchService) {
+                const collectionPath = collection.slug;
+                const entities = await fetchService.fetchCollectionForRest(
+                    collectionPath,
+                    {
+                        filter: queryOptions.where as FetchCollectionProps["filter"],
+                        limit: queryOptions.limit,
+                        orderBy: queryOptions.orderBy?.[0]?.field,
+                        order: queryOptions.orderBy?.[0]?.direction === "desc" ? "desc" : "asc",
+                        searchString: queryDict.searchString as string | undefined,
+                    },
+                    queryOptions.include
+                );
+
+                const total = await this.countRawEntities(driver, resolvedCollection, queryOptions);
+
+                return c.json({
+                    data: entities,
+                    meta: {
+                        total,
+                        limit: queryOptions.limit,
+                        offset: queryOptions.offset,
+                        hasMore: (queryOptions.offset || 0) + (entities as unknown[]).length < total
+                    }
+                });
+            }
+
+            // Fallback for non-Postgres drivers
+            const entities = await this.fetchRawCollection(driver, resolvedCollection, queryOptions);
+            const total = await this.countRawEntities(driver, resolvedCollection, queryOptions);
+
+            return c.json({
+                data: entities,
+                meta: {
+                    total,
+                    limit: queryOptions.limit,
+                    offset: queryOptions.offset,
+                    hasMore: (queryOptions.offset || 0) + (entities as unknown[]).length < total
+                }
+            });
+        });
+
+        // GET /collection/:id - Get single entity
+        this.router.get(`${basePath}/:id`, async (c) => {
+            const id = c.req.param("id");
+            const queryDict = c.req.query();
+            const queryOptions = parseQueryOptions(queryDict);
+            const driver = c.get("driver") || this.driver;
+            const fetchService = this.getFetchService(driver);
+
+            // Use include-aware path when available
+            if (fetchService) {
+                const collectionPath = collection.slug;
+                const entity = await fetchService.fetchEntityForRest(
+                    collectionPath,
+                    String(id),
+                    queryOptions.include
+                );
+
+                if (!entity) {
+                    throw ApiError.notFound("Entity not found");
+                }
+
+                return c.json(entity);
+            }
+
+            // Fallback
+            const entity = await this.fetchRawEntity(driver, resolvedCollection, String(id));
+
+            if (!entity) {
+                throw ApiError.notFound("Entity not found");
+            }
+
+            return c.json(entity);
+        });
+
+        // POST /collection - Create entity
+        this.router.post(basePath, async (c) => {
+            try {
+                const driver = c.get("driver") || this.driver;
+                const path = collection.slug;
+                
+                const body = await c.req.json().catch(() => ({}));
+
+                const entity = await driver.saveEntity({
+                    path,
+                    values: body,
+                    collection: resolvedCollection,
+                    status: "new"
+                });
+
+                return c.json(this.formatResponse(entity), 201);
+            } catch (error) {
+                const err = error as Error & { code?: string };
+                err.code = err.code || "BAD_REQUEST";
+                throw err;
+            }
+        });
+
+        // PUT /collection/:id - Update entity
+        this.router.put(`${basePath}/:id`, async (c) => {
+            try {
+                const id = c.req.param("id");
+                const driver = c.get("driver") || this.driver;
+
+                const existingEntity = await driver.fetchEntity({
+                    path: collection.slug,
+                    entityId: String(id),
+                    collection: resolvedCollection
+                });
+
+                if (!existingEntity) {
+                    throw ApiError.notFound("Entity not found");
+                }
+
+                const body = await c.req.json().catch(() => ({}));
+
+                const entity = await driver.saveEntity({
+                    path: collection.slug,
+                    entityId: String(id),
+                    values: body,
+                    collection: resolvedCollection,
+                    status: "existing"
+                });
+
+                return c.json(this.formatResponse(entity));
+            } catch (error) {
+                const err = error as Error & { code?: string };
+                err.code = err.code || "BAD_REQUEST";
+                throw err;
+            }
+        });
+
+        // DELETE /collection/:id - Delete entity
+        this.router.delete(`${basePath}/:id`, async (c) => {
+            const id = c.req.param("id");
+            const driver = c.get("driver") || this.driver;
+
+            const existingEntity = await driver.fetchEntity({
+                path: collection.slug,
+                entityId: String(id),
+                collection: resolvedCollection
+            });
+
+            if (!existingEntity) {
+                throw ApiError.notFound("Entity not found");
+            }
+
+            await driver.deleteEntity({
+                entity: existingEntity,
+                collection: resolvedCollection
+            });
+
+            return new Response(null, { status: 204 });
+        });
+    }
+
+    /**
+     * Catch-all routes for subcollection paths.
+     *
+     * Matches URL patterns like:
+     *   GET    /authors/111094/posts          → list child collection
+     *   GET    /authors/111094/posts/43       → get child entity
+     *   POST   /authors/111094/posts          → create child entity
+     *   PUT    /authors/111094/posts/43       → update child entity
+     *   DELETE /authors/111094/posts/43       → delete child entity
+     *
+     * The `:rest{.+}` regex param captures the full remainder of the URL
+     * path (Hono v4 `*` wildcard does not populate `c.req.param("*")`).
+     * We split it into segments and reconstruct the `collectionPath`
+     * (e.g. "authors/111094/posts") and optional `entityId` (e.g. "43").
+     *
+     * The DataDriver.saveEntity / fetchCollection / etc. already know how to
+     * resolve multi-segment relation paths, so we just forward to them.
+     */
+    private createSubcollectionRoutes(): void {
+        // Reserved path segments that should NOT be treated as relation names.
+        // These are handled by dedicated route handlers (e.g., history routes)
+        // mounted on the same data router.
+        const RESERVED_SEGMENTS = new Set(["history"]);
+
+        // Helper: parse a path like "authors/111094/posts/43" into
+        // { collectionPath: "authors/111094/posts", entityId: "43" }
+        // or "authors/111094/posts" into
+        // { collectionPath: "authors/111094/posts", entityId: undefined }
+        const parseSubPath = (rawPath: string): { collectionPath: string; entityId?: string } | null => {
+            const segments = rawPath.split("/").filter(s => s && s !== "undefined");
+            // Need at least 3 segments for a subcollection path (parent/id/child)
+            if (segments.length < 3) return null;
+
+            // If any segment is a reserved path (e.g. "history"), this is not a
+            // subcollection route — let it fall through to other handlers.
+            if (segments.some(s => RESERVED_SEGMENTS.has(s))) return null;
+
+            // Odd segment count → collection path (parent/id/child or parent/id/child/id2/grandchild)
+            // Even segment count → entity path   (parent/id/child/entityId)
+            if (segments.length % 2 === 1) {
+                return { collectionPath: segments.join("/") };
+            } else {
+                const entityId = segments.pop()!;
+                return { collectionPath: segments.join("/"), entityId };
+            }
+        };
+
+        // GET /<subcollection-path> — list or get single entity
+        // Use :rest{.+} instead of * because Hono v4's wildcard doesn't
+        // capture into c.req.param("*") — it always returns undefined.
+        this.router.get("/:parent/:parentId/:rest{.+}", async (c, next) => {
+            const rest = c.req.param("rest");
+            if (!rest || rest === "undefined") return next();
+            const rawPath = `${c.req.param("parent")}/${c.req.param("parentId")}/${rest}`;
+            const parsed = parseSubPath(rawPath);
+            if (!parsed) return next();
+
+            const driver = c.get("driver") || this.driver;
+
+            if (parsed.entityId) {
+                // GET /parent/:parentId/child/:id — single entity
+                const entity = await driver.fetchEntity({
+                    path: parsed.collectionPath,
+                    entityId: parsed.entityId
+                });
+                if (!entity) throw ApiError.notFound("Entity not found");
+                return c.json(this.flattenEntity(entity));
+            } else {
+                // GET /parent/:parentId/child — list entities
+                const queryDict = c.req.query();
+                const queryOptions = parseQueryOptions(queryDict);
+                const entities = await driver.fetchCollection({
+                    path: parsed.collectionPath,
+                    filter: queryOptions.where as FetchCollectionProps["filter"],
+                    limit: queryOptions.limit,
+                    orderBy: queryOptions.orderBy?.[0]?.field,
+                    order: queryOptions.orderBy?.[0]?.direction === "desc" ? "desc" : "asc",
+                    searchString: queryDict.searchString as string | undefined
+                });
+                return c.json({
+                    data: entities.map(e => this.flattenEntity(e)),
+                    meta: {
+                        total: entities.length,
+                        limit: queryOptions.limit,
+                        offset: queryOptions.offset,
+                        hasMore: false
+                    }
+                });
+            }
+        });
+
+        // POST /<subcollection-path> — create entity
+        this.router.post("/:parent/:parentId/:rest{.+}", async (c, next) => {
+            const rest = c.req.param("rest");
+            if (!rest || rest === "undefined") return next();
+            const rawPath = `${c.req.param("parent")}/${c.req.param("parentId")}/${rest}`;
+            const parsed = parseSubPath(rawPath);
+            if (!parsed || parsed.entityId) return next();
+
+            const driver = c.get("driver") || this.driver;
+            const body = await c.req.json().catch(() => ({}));
+
+            const entity = await driver.saveEntity({
+                path: parsed.collectionPath,
+                values: body,
+                status: "new"
+            });
+
+            return c.json(this.formatResponse(entity), 201);
+        });
+
+        // PUT /<subcollection-path>/:id — update entity
+        this.router.put("/:parent/:parentId/:rest{.+}", async (c, next) => {
+            const rest = c.req.param("rest");
+            if (!rest || rest === "undefined") return next();
+            const rawPath = `${c.req.param("parent")}/${c.req.param("parentId")}/${rest}`;
+            const parsed = parseSubPath(rawPath);
+            if (!parsed || !parsed.entityId) return next();
+
+            const driver = c.get("driver") || this.driver;
+            const body = await c.req.json().catch(() => ({}));
+
+            const entity = await driver.saveEntity({
+                path: parsed.collectionPath,
+                entityId: parsed.entityId,
+                values: body,
+                status: "existing"
+            });
+
+            return c.json(this.formatResponse(entity));
+        });
+
+        // DELETE /<subcollection-path>/:id — delete entity
+        this.router.delete("/:parent/:parentId/:rest{.+}", async (c, next) => {
+            const rest = c.req.param("rest");
+            if (!rest || rest === "undefined") return next();
+            const rawPath = `${c.req.param("parent")}/${c.req.param("parentId")}/${rest}`;
+            const parsed = parseSubPath(rawPath);
+            if (!parsed || !parsed.entityId) return next();
+
+            const driver = c.get("driver") || this.driver;
+
+            const existingEntity = await driver.fetchEntity({
+                path: parsed.collectionPath,
+                entityId: parsed.entityId
+            });
+
+            if (!existingEntity) throw ApiError.notFound("Entity not found");
+
+            await driver.deleteEntity({ entity: existingEntity });
+
+            return new Response(null, { status: 204 });
+        });
+    }
+
+    /**
+     * Format successful API response - flattened for traditional REST API
+     */
+    private formatResponse<T>(data: T, meta?: Record<string, unknown>): unknown {
+        if (Array.isArray(data)) {
+            const flattenedData = data.map(entity => this.flattenEntity(entity));
+            if (meta) {
+                return {
+                    data: flattenedData,
+                    meta
+                };
+            }
+            return flattenedData;
+        }
+
+        if (data && typeof data === "object" && "values" in data) {
+            return this.flattenEntity(data as unknown as Entity<Record<string, unknown>>);
+        }
+
+        if (meta) {
+            return {
+                data,
+                meta
+            };
+        }
+        return data;
+    }
+
+    /**
+     * Flatten Rebase entity structure to traditional REST format
+     */
+    private flattenEntity(entity: Entity<Record<string, unknown>>): Record<string, unknown> {
+        if (!entity || typeof entity !== "object") {
+            return entity;
+        }
+
+        if ("values" in entity && typeof entity.values === "object") {
+            return {
+                id: entity.id,
+                ...entity.values
+            };
+        }
+
+        return entity as unknown as Record<string, unknown>;
+    }
+
+    /**
+     * Fetch raw collection data without Entity wrapper (fallback for non-Postgres)
+     */
+    private async fetchRawCollection(driver: DataDriver, collection: EntityCollection, queryOptions: QueryOptions) {
+        const entities = await driver.fetchCollection({
+            path: collection.slug,
+            collection,
+            filter: queryOptions.where as FetchCollectionProps["filter"],
+            limit: queryOptions.limit,
+            orderBy: queryOptions.orderBy?.[0]?.field,
+            order: queryOptions.orderBy?.[0]?.direction === "desc" ? "desc" : "asc",
+            startAfter: queryOptions.offset ? String(queryOptions.offset) : undefined
+        });
+
+        return entities.map(entity => this.flattenEntity(entity));
+    }
+
+    /**
+     * Count raw entities for a collection
+     */
+    private async countRawEntities(driver: DataDriver, collection: EntityCollection, queryOptions: QueryOptions): Promise<number> {
+        return driver.countEntities ? await driver.countEntities({
+            path: collection.slug,
+            collection,
+            filter: queryOptions.where as FetchCollectionProps["filter"]
+        }) : 0;
+    }
+
+    /**
+     * Fetch single entity raw data without Entity wrapper (fallback)
+     */
+    private async fetchRawEntity(driver: DataDriver, collection: EntityCollection, entityId: string) {
+        const entity = await driver.fetchEntity({
+            path: collection.slug,
+            entityId,
+            collection
+        });
+
+        return entity ? this.flattenEntity(entity) : null;
+    }
+}

package/src/api/rest/index.ts

@@ -0,0 +1,2 @@
+export * from "./api-generator";
+

package/src/api/rest/query-parser.ts

@@ -0,0 +1,155 @@
+import { QueryOptions } from "../types";
+
+/**
+ * Map PostgREST-style operators to Rebase WhereFilterOp
+ */
+export function mapOperator(op: string): string | null {
+    switch (op) {
+        case "eq": return "==";
+        case "neq": return "!=";
+        case "gt": return ">";
+        case "gte": return ">=";
+        case "lt": return "<";
+        case "lte": return "<=";
+        case "in": return "in";
+        case "nin": return "not-in";
+        case "cs": return "array-contains";
+        case "csa": return "array-contains-any";
+        default: return null;
+    }
+}
+
+/**
+ * Parse query parameters into QueryOptions
+ */
+export function parseQueryOptions(query: Record<string, unknown>): QueryOptions {
+    const options: QueryOptions = {};
+
+    // Pagination
+    if (query.limit) options.limit = parseInt(String(query.limit));
+    if (query.offset) options.offset = parseInt(String(query.offset));
+    if (query.page) {
+        const page = parseInt(String(query.page));
+        const limit = options.limit || 20;
+        options.offset = (page - 1) * limit;
+    }
+
+    // Filtering
+    options.where = {};
+
+    // Legacy JSON where clause
+    if (query.where) {
+        try {
+            const parsedWhere = typeof query.where === "string"
+                ? JSON.parse(query.where)
+                : query.where;
+            if (typeof parsedWhere !== "object" || parsedWhere === null || Array.isArray(parsedWhere)) {
+                throw new Error("Filter must be a JSON object");
+            }
+            Object.assign(options.where, parsedWhere);
+        } catch (e) {
+            const message = e instanceof Error ? e.message : "malformed JSON";
+            const err = new Error(`Invalid 'where' filter: ${message}`) as Error & { code?: string; statusCode?: number };
+            err.code = "BAD_REQUEST";
+            err.statusCode = 400;
+            throw err;
+        }
+    }
+
+    // PostgREST style filtering
+    const reservedQueryKeys = ["limit", "offset", "page", "orderBy", "where", "include", "fields"];
+    for (const [key, rawValue] of Object.entries(query)) {
+        if (reservedQueryKeys.includes(key)) continue;
+
+        const value = Array.isArray(rawValue) ? rawValue[rawValue.length - 1] : rawValue;
+
+        if (typeof value === "string") {
+            const parts = value.split(".");
+            if (parts.length >= 2) {
+                const op = parts[0];
+                const val = parts.slice(1).join(".");
+                const rebaseOp = mapOperator(op);
+
+                if (rebaseOp) {
+                    let parsedVal: string | number | boolean | null | (string | number | boolean | null)[] = val;
+                    // Attempt to parse primitive types or arrays
+                    if (val === "true") parsedVal = true;
+                    else if (val === "false") parsedVal = false;
+                    else if (val === "null") parsedVal = null;
+                    else if (!isNaN(Number(val)) && val.trim() !== "") parsedVal = Number(val);
+                    else if (val.startsWith("(")) {
+                        // Array for 'in' or 'not-in' ops (e.g. (1,2,3) or (a,b,c))
+                        const arrayContent = val.endsWith(")") ? val.slice(1, -1) : val.slice(1);
+                        parsedVal = arrayContent.split(",").map(v => {
+                            const trimmed = v.trim();
+                            if (!isNaN(Number(trimmed)) && trimmed !== "") return Number(trimmed);
+                            if (trimmed === "true") return true;
+                            if (trimmed === "false") return false;
+                            if (trimmed === "null") return null;
+                            return trimmed;
+                        });
+                    }
+
+                    options.where[key] = [rebaseOp, parsedVal];
+                } else {
+                    // Fallback: assume implicit eq if the dot wasn't an operator (e.g. email or float)
+                    let parsedVal: string | number | boolean | null = value;
+                    if (!isNaN(Number(value)) && value.trim() !== "") parsedVal = Number(value);
+                    options.where[key] = ["==", parsedVal];
+                }
+            } else {
+                // Implicit eq
+                let parsedVal: string | number | boolean | null = value;
+                if (value === "true") parsedVal = true;
+                else if (value === "false") parsedVal = false;
+                else if (value === "null") parsedVal = null;
+                else if (!isNaN(Number(value)) && value.trim() !== "") parsedVal = Number(value);
+
+                options.where[key] = ["==", parsedVal];
+            }
+        }
+    }
+
+    if (Object.keys(options.where).length === 0) {
+        delete options.where;
+    }
+
+    // Sorting
+    if (query.orderBy) {
+        try {
+            options.orderBy = typeof query.orderBy === "string"
+                ? JSON.parse(query.orderBy)
+                : query.orderBy;
+        } catch {
+            // Try simple format: "field:direction"
+            if (typeof query.orderBy === "string") {
+                const [field, direction] = query.orderBy.split(":");
+                const dir = (direction === "desc" ? "desc" : "asc") as "asc" | "desc";
+                options.orderBy = [
+                    {
+                        field,
+                        direction: dir
+                    }
+                ];
+            }
+        }
+    }
+
+    // Relation includes
+    if (query.include) {
+        const includeStr = String(query.include).trim();
+        if (includeStr === "*") {
+            options.include = ["*"];
+        } else {
+            options.include = includeStr.split(",").map(s => s.trim()).filter(Boolean);
+        }
+    }
+
+    // Field selection
+    if (query.fields) {
+        const fieldsStr = String(query.fields).trim();
+        options.fields = fieldsStr.split(",").map(s => s.trim()).filter(Boolean);
+    }
+
+    return options;
+}

package/src/api/schema-editor-routes.ts

@@ -0,0 +1,39 @@
+import { Hono } from "hono";
+import { AstSchemaEditor } from "./ast-schema-editor";
+import { HonoEnv } from "./types";
+
+export function createSchemaEditorRoutes(collectionsDir: string): Hono<HonoEnv> {
+    const router = new Hono<HonoEnv>();
+    const editor = new AstSchemaEditor(collectionsDir);
+
+    router.post("/property/save", async (c) => {
+        const body = await c.req.json();
+        const { collectionId, propertyKey, propertyConfig } = body;
+        await editor.saveProperty(collectionId, propertyKey, propertyConfig);
+        return c.json({ success: true });
+    });
+
+    router.post("/property/delete", async (c) => {
+        const body = await c.req.json();
+        const { collectionId, propertyKey } = body;
+        await editor.deleteProperty(collectionId, propertyKey);
+        return c.json({ success: true });
+    });
+
+    router.post("/collection/save", async (c) => {
+        const body = await c.req.json();
+        const { collectionId, collectionData } = body;
+        await editor.saveCollection(collectionId, collectionData);
+        return c.json({ success: true });
+    });
+
+    router.post("/collection/delete", async (c) => {
+        const body = await c.req.json();
+        const { collectionId } = body;
+        await editor.deleteCollection(collectionId);
+        return c.json({ success: true });
+    });
+
+    return router;
+}
+