@rebasepro/server-core 0.7.0 → 0.9.0

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

@@ -1,300 +0,0 @@
-import type { VectorSearchParams, LogicalCondition, FilterCondition } from "@rebasepro/types";
-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;
-    }
-}
-
-function getLastValue(val: unknown): unknown {
-    if (Array.isArray(val)) {
-        return val[val.length - 1];
-    }
-    return val;
-}
-
-export function parseLogicalString(str: string): FilterCondition | LogicalCondition {
-    str = str.trim();
-    if (str.startsWith("or(") && str.endsWith(")")) {
-        const inner = str.slice(3, -1);
-        return { type: "or",
-conditions: parseLogicalList(inner) };
-    }
-    if (str.startsWith("and(") && str.endsWith(")")) {
-        const inner = str.slice(4, -1);
-        return { type: "and",
-conditions: parseLogicalList(inner) };
-    }
-
-    // It's a leaf condition: field.op.val
-    const firstDot = str.indexOf(".");
-    if (firstDot === -1) {
-        return { column: str,
-operator: "==",
-value: true };
-    }
-    const field = str.substring(0, firstDot);
-    const rest = str.substring(firstDot + 1);
-    const secondDot = rest.indexOf(".");
-    let op = "eq";
-    let valStr = rest;
-    if (secondDot !== -1) {
-        op = rest.substring(0, secondDot);
-        valStr = rest.substring(secondDot + 1);
-    } else {
-        op = "eq";
-        valStr = rest;
-    }
-
-    const rebaseOp = (mapOperator(op) || "==") as FilterCondition["operator"];
-    let parsedVal: unknown = valStr;
-    if (valStr === "true") parsedVal = true;
-    else if (valStr === "false") parsedVal = false;
-    else if (valStr === "null") parsedVal = null;
-    else if (!isNaN(Number(valStr)) && valStr.trim() !== "") parsedVal = Number(valStr);
-    else if (valStr.startsWith("(")) {
-        const arrayContent = valStr.endsWith(")") ? valStr.slice(1, -1) : valStr.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;
-        });
-    }
-
-    return { column: field,
-operator: rebaseOp,
-value: parsedVal };
-}
-
-function parseLogicalList(str: string): (FilterCondition | LogicalCondition)[] {
-    const list: (FilterCondition | LogicalCondition)[] = [];
-    let depth = 0;
-    let current = "";
-
-    for (let i = 0; i < str.length; i++) {
-        const char = str[i];
-        if (char === "(") depth++;
-        if (char === ")") depth--;
-
-        if (char === "," && depth === 0) {
-            list.push(parseLogicalString(current));
-            current = "";
-        } else {
-            current += char;
-        }
-    }
-    if (current) {
-        list.push(parseLogicalString(current));
-    }
-    return list;
-}
-
-/**
- * Parse query parameters into QueryOptions
- */
-export function parseQueryOptions(query: Record<string, unknown>): QueryOptions {
-    const options: QueryOptions = {};
-
-    // Pagination
-    const limitVal = getLastValue(query.limit);
-    if (limitVal) options.limit = parseInt(String(limitVal));
-
-    const offsetVal = getLastValue(query.offset);
-    if (offsetVal) options.offset = parseInt(String(offsetVal));
-
-    const pageVal = getLastValue(query.page);
-    if (pageVal) {
-        const page = parseInt(String(pageVal));
-        const limit = options.limit || 20;
-        options.offset = (page - 1) * limit;
-    }
-
-    // Filtering
-    options.where = {};
-
-    // Handle logical conditions
-    const orVal = getLastValue(query.or);
-    const andVal = getLastValue(query.and);
-    if (orVal) {
-        let orStr = String(orVal).trim();
-        if (orStr.startsWith("(") && orStr.endsWith(")")) {
-            orStr = orStr.slice(1, -1);
-        }
-        options.logical = {
-            type: "or",
-            conditions: parseLogicalList(orStr)
-        };
-    } else if (andVal) {
-        let andStr = String(andVal).trim();
-        if (andStr.startsWith("(") && andStr.endsWith(")")) {
-            andStr = andStr.slice(1, -1);
-        }
-        options.logical = {
-            type: "and",
-            conditions: parseLogicalList(andStr)
-        };
-    }
-
-    // PostgREST-style filtering: ?field=op.value
-    const reservedQueryKeys = ["limit", "offset", "page", "orderBy", "include", "fields", "searchString", "vector_search", "vector", "vector_distance", "vector_threshold", "or", "and"];
-    for (const [key, rawValue] of Object.entries(query)) {
-        if (reservedQueryKeys.includes(key)) continue;
-
-        const rawValues = Array.isArray(rawValue) ? rawValue : [rawValue];
-        const conditions: [string, unknown][] = [];
-
-        for (const value of rawValues) {
-            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;
-                            });
-                        }
-
-                        conditions.push([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);
-                        conditions.push(["==", 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);
-
-                    conditions.push(["==", parsedVal]);
-                }
-            }
-        }
-
-        if (conditions.length > 0) {
-            options.where[key] = conditions.length === 1 ? conditions[0] : conditions;
-        }
-    }
-
-    if (Object.keys(options.where).length === 0) {
-        delete options.where;
-    }
-
-    // Sorting
-    const orderByVal = getLastValue(query.orderBy);
-    if (orderByVal) {
-        try {
-            options.orderBy = typeof orderByVal === "string"
-                ? JSON.parse(orderByVal)
-                : orderByVal;
-        } catch {
-            // Try simple format: "field:direction"
-            if (typeof orderByVal === "string") {
-                const [field, direction] = orderByVal.split(":");
-                const dir = (direction === "desc" ? "desc" : "asc") as "asc" | "desc";
-                options.orderBy = [
-                    {
-                        field,
-                        direction: dir
-                    }
-                ];
-            }
-        }
-    }
-
-    // Relation includes
-    const includeVal = getLastValue(query.include);
-    if (includeVal) {
-        const includeStr = String(includeVal).trim();
-        if (includeStr === "*") {
-            options.include = ["*"];
-        } else {
-            options.include = includeStr.split(",").map(s => s.trim()).filter(Boolean);
-        }
-    }
-
-    // Field selection
-    const fieldsVal = getLastValue(query.fields);
-    if (fieldsVal) {
-        const fieldsStr = String(fieldsVal).trim();
-        options.fields = fieldsStr.split(",").map(s => s.trim()).filter(Boolean);
-    }
-
-    // Vector similarity search
-    const vectorSearchVal = getLastValue(query.vector_search);
-    const vectorVal = getLastValue(query.vector);
-    if (vectorSearchVal && vectorVal) {
-        const vectorStr = String(vectorVal);
-        let queryVector: number[];
-        try {
-            queryVector = JSON.parse(vectorStr) as number[];
-            if (!Array.isArray(queryVector) || !queryVector.every(v => typeof v === "number")) {
-                throw new Error("Expected array of numbers");
-            }
-        } catch {
-            throw new Error("Invalid vector format. Expected JSON array of numbers, e.g. [0.1,0.2,0.3]");
-        }
-
-        const distanceParamVal = getLastValue(query.vector_distance);
-        const distanceParam = distanceParamVal ? String(distanceParamVal) : "cosine";
-        if (distanceParam !== "cosine" && distanceParam !== "l2" && distanceParam !== "inner_product") {
-            throw new Error(`Invalid vector_distance: ${distanceParam}. Expected: cosine, l2, or inner_product`);
-        }
-
-        const vectorSearch: VectorSearchParams = {
-            property: String(vectorSearchVal),
-            vector: queryVector,
-            distance: distanceParam
-        };
-
-        const thresholdVal = getLastValue(query.vector_threshold);
-        if (thresholdVal) {
-            const threshold = parseFloat(String(thresholdVal));
-            if (isNaN(threshold)) {
-                throw new Error("Invalid vector_threshold. Expected a number.");
-            }
-            vectorSearch.threshold = threshold;
-        }
-
-        options.vectorSearch = vectorSearch;
-    }
-
-    return options;
-}

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

@@ -1,41 +0,0 @@
-import { Hono } from "hono";
-import { AstSchemaEditor } from "./ast-schema-editor";
-import { errorHandler } from "./errors";
-import { HonoEnv } from "./types";
-
-export function createSchemaEditorRoutes(collectionsDir: string): Hono<HonoEnv> {
-    const router = new Hono<HonoEnv>();
-    router.onError(errorHandler);
-    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;
-}
-

package/src/api/server.ts

@@ -1,271 +0,0 @@
-import { Hono } from "hono";
-import { cors } from "hono/cors";
-import { secureHeaders } from "hono/secure-headers";
-import { graphqlServer } from "@hono/graphql-server";
-import { serve } from "@hono/node-server";
-import { GraphQLSchemaGenerator } from "./graphql/graphql-schema-generator";
-import { RestApiGenerator } from "./rest/api-generator";
-import { DataDriver, EntityCollection, Relation } from "@rebasepro/types";
-import { createDataSourceRegistry, resolveDataSource } from "@rebasepro/common";
-import { ApiConfig, HonoEnv } from "./types";
-import { loadCollectionsFromDirectory } from "../collections/loader";
-import { createSchemaEditorRoutes } from "./schema-editor-routes";
-import { createAuthMiddleware, requireAuth, requireAdmin } from "../auth/middleware";
-import { errorHandler } from "./errors";
-import { generateOpenApiSpec } from "./openapi-generator";
-import { requestId } from "../utils/request-id";
-import { logger } from "../utils/logger";
-
-/**
- * Simplified API server that leverages existing Rebase infrastructure
- * Can be used standalone or mounted on existing Hono app
- */
-export class RebaseApiServer {
-    private app: Hono<HonoEnv>;
-    private router: Hono<HonoEnv>;
-    private config: ApiConfig;
-    private driver: DataDriver;
-
-    private constructor(config: ApiConfig & { driver: DataDriver }) {
-        this.config = {
-            basePath: "/api",
-            enableGraphQL: true,
-            enableREST: true,
-            pagination: {
-                defaultLimit: 20,
-                maxLimit: 100
-            },
-            ...config
-        };
-
-        this.driver = config.driver;
-
-        this.app = new Hono<HonoEnv>();
-        this.router = new Hono<HonoEnv>();
-
-        this.setupMiddleware();
-    }
-
-    /**
-     * Factory method to create an asynchronously initialized ApiServer instance
-     */
-    public static async create(config: ApiConfig & { driver: DataDriver }): Promise<RebaseApiServer> {
-        if (config.collectionsDir && (!config.collections || config.collections.length === 0)) {
-            config.collections = await loadCollectionsFromDirectory(config.collectionsDir);
-        } else if (!config.collections) {
-            config.collections = [];
-        }
-
-        const server = new RebaseApiServer(config);
-        server.setupRoutes();
-        // Since we mount routes directly to router, we can let consumer attach it
-        server.app.route("/", server.router);
-
-        // Hono global error handler on the root app
-        server.app.onError(errorHandler);
-        server.router.onError(errorHandler);
-
-        return server;
-    }
-
-    /**
-     * Setup Hono middleware
-     */
-    private setupMiddleware(): void {
-        // Request ID — must be first so all downstream middleware can access it
-        this.router.use("/*", requestId());
-
-        // Security headers — use same-origin-allow-popups for COOP so that
-        // OAuth popup flows (Google, etc.) can postMessage back to the opener.
-        this.router.use("/*", secureHeaders({
-            crossOriginOpenerPolicy: "same-origin-allow-popups"
-        }));
-
-        // CORS — only applied if explicitly configured via `cors` option.
-        // If omitted, the user is expected to configure CORS on their own
-        // Hono app before mounting the API (recommended approach).
-        if (this.config.cors) {
-            const origin = this.config.cors.origin;
-            this.router.use("/*", cors({
-                origin: typeof origin === "boolean"
-                    ? (origin ? ((o: string) => o) : "")
-                    : (origin ?? "*"),
-                credentials: this.config.cors.credentials ?? false
-            }));
-        } else if (process.env.NODE_ENV !== "production") {
-            logger.warn(
-                "⚠️  [RebaseApiServer] No CORS configuration provided. " +
-                "The API will accept requests from any origin. " +
-                "Pass a `cors` option or configure CORS on your Hono app."
-            );
-        }
-
-        // Auth middleware
-        this.router.use("/*", createAuthMiddleware({
-            driver: this.driver,
-            requireAuth: this.config.requireAuth ?? true,
-            validator: this.config.authValidator
-        }));
-    }
-
-    /**
-     * Setup API routes using existing services
-     */
-    private setupRoutes(): void {
-        const basePath = this.config.basePath!;
-
-        // Health check
-        this.router.get(`${basePath}/health`, (c) => {
-            return c.json({
-                status: "healthy",
-                timestamp: new Date().toISOString(),
-                collections: this.config.collections?.map((col: EntityCollection) => col.slug) || [],
-                driver: this.driver.key
-            });
-        });
-
-        // Collections metadata endpoint
-        this.router.get(`${basePath}/collections`, (c) => {
-            const collectionsMetadata = (this.config.collections || []).map((col: EntityCollection) => ({
-                slug: col.slug,
-                name: col.name,
-                singularName: col.singularName,
-                description: col.description,
-                properties: Object.keys(col.properties),
-                relations: col.relations?.map((r: Relation) => ({
-                    relationName: r.relationName,
-                    target: typeof r.target === "function" ? r.target().slug : r.target,
-                    cardinality: r.cardinality,
-                    direction: r.direction
-                })) || []
-            }));
-
-            return c.json({ data: collectionsMetadata });
-        });
-
-        // Server data routes are only generated for server-transport
-        // collections; direct/custom sources are client-only.
-        const dataSourceRegistry = createDataSourceRegistry(this.config.dataSources);
-        const serverCollections = (this.config.collections || []).filter(
-            (collection) => resolveDataSource(collection, dataSourceRegistry).transport === "server"
-        );
-
-        // GraphQL endpoint
-        if (this.config.enableGraphQL) {
-            const schemaGenerator = new GraphQLSchemaGenerator(serverCollections, this.driver);
-            const schema = schemaGenerator.generateSchema();
-
-            // Context is automatically passed to resolvers via contextValue containing Hono's 'c'
-            this.router.use(`${basePath}/graphql`, graphqlServer({
-                schema
-            }));
-
-            // Lightweight GraphiQL IDE
-            if (process.env.NODE_ENV !== "production") {
-                this.router.get(`${basePath}/graphiql`, (c) => {
-                    return c.html(`<!DOCTYPE html>
-<html>
-<head>
-  <meta charset=utf-8/>
-  <title>Rebase GraphiQL</title>
-  <link rel="stylesheet" href="https://unpkg.com/graphiql/graphiql.min.css" />
-  <style>body,html,#graphiql{height:100%;margin:0;width:100%;}</style>
-</head>
-<body>
-<div id="graphiql">Loading...</div>
-<script crossorigin src="https://unpkg.com/react/umd/react.production.min.js"></script>
-<script crossorigin src="https://unpkg.com/react-dom/umd/react-dom.production.min.js"></script>
-<script src="https://unpkg.com/graphiql/graphiql.min.js"></script>
-<script>
-  const fetcher = GraphiQL.createFetcher({ url: '${basePath}/graphql' });
-  ReactDOM.render(
-    React.createElement(GraphiQL, { fetcher }),
-    document.getElementById('graphiql'),
-  );
-</script>
-</body>
-</html>`);
-                });
-            }
-        }
-
-        if (this.config.enableREST) {
-            const restGenerator = new RestApiGenerator(serverCollections, this.driver);
-            const restRoutes = restGenerator.generateRoutes();
-            this.router.route(basePath, restRoutes);
-        }
-
-        // Schema Editor endpoints
-        if (this.config.collectionsDir) {
-            if (process.env.NODE_ENV === "production") {
-                logger.warn("[RebaseApiServer] Schema Editor is disabled in production environments for security.");
-            } else {
-                // Auth middlewares applied to schema-editor via the router prefix
-                // MUST be declared before .route() so they execute first
-                this.router.use(`${basePath}/schema-editor/*`, requireAuth, requireAdmin);
-                const schemaEditorRoutes = createSchemaEditorRoutes(this.config.collectionsDir);
-                this.router.route(`${basePath}/schema-editor`, schemaEditorRoutes);
-            }
-        }
-
-        // OpenAPI endpoint
-        this.router.get(`${basePath}/docs`, (c) => {
-            const openApiSpec = generateOpenApiSpec(this.config.collections || [], {
-                basePath: this.config.basePath,
-                requireAuth: this.config.requireAuth ?? true
-            });
-            return c.json(openApiSpec);
-        });
-
-        // Simple Swagger UI
-        if (process.env.NODE_ENV !== "production") {
-            this.router.get(`${basePath}/swagger`, (c) => {
-                return c.html(`
-                    <!DOCTYPE html>
-                    <html>
-                    <head>
-                        <title>Rebase API Documentation</title>
-                        <link rel="stylesheet" type="text/css" href="https://unpkg.com/swagger-ui-dist@4.15.5/swagger-ui.css" />
-                    </head>
-                    <body>
-                        <div id="swagger-ui"></div>
-                        <script src="https://unpkg.com/swagger-ui-dist@4.15.5/swagger-ui-bundle.js"></script>
-                        <script>
-                            SwaggerUIBundle({
-                                url: '${basePath}/docs',
-                                dom_id: '#swagger-ui'
-                            });
-                        </script>
-                    </body>
-                    </html>
-                `);
-            });
-        }
-    }
-
-    /**
-     * Get the Hono router with all API routes
-     */
-    getRouter(): Hono<HonoEnv> {
-        return this.router;
-    }
-
-    /**
-     * Get the standalone Hono app
-     */
-    getApp(): Hono<HonoEnv> {
-        return this.app;
-    }
-
-    /**
-     * Start the server (standalone mode) via @hono/node-server
-     */
-    listen(port = 3000, callback?: () => void): void {
-        serve({
-            fetch: this.app.fetch,
-            port
-        }, () => {
-            if (callback) callback();
-        });
-    }
-}