@rebasepro/server-core 0.6.0 → 0.7.0

package/test/transform-auth-response.test.ts

@@ -0,0 +1,305 @@
+/**
+ * transformAuthResponse Hook — Integration Tests
+ *
+ * Tests the `transformAuthResponse` hook across login, register, refresh,
+ * and error handling scenarios. Services are mocked following the same
+ * pattern as auth-routes.test.ts.
+ */
+
+import { Hono } from "hono";
+import type { HonoEnv } from "../src/api/types";
+import { errorHandler } from "../src/api/errors";
+import { createAuthRoutes, AuthModuleConfig } from "../src/auth/routes";
+import type { AuthRepository } from "../src/auth/interfaces";
+import { configureJwt, hashRefreshToken } from "../src/auth/jwt";
+import type { AuthHooks } from "../src/auth/auth-hooks";
+import type { AuthResponsePayload, TransformAuthResponseContext } from "@rebasepro/types";
+
+// ── Mocks ───────────────────────────────────────────────────────────────────
+
+jest.mock("../src/auth/password");
+
+jest.mock("../src/utils/logger", () => {
+    return {
+        logger: {
+            info: jest.fn(),
+            warn: jest.fn(),
+            error: jest.fn(),
+            debug: jest.fn(),
+            child: jest.fn().mockReturnThis()
+        }
+    };
+});
+
+// Bypass rate limiters — they share state across tests and cause 429s
+jest.mock("../src/auth/rate-limiter", () => {
+    const passthrough = async (_c: unknown, next: () => Promise<void>) => next();
+    return {
+        createRateLimiter: () => passthrough,
+        defaultAuthLimiter: passthrough,
+        strictAuthLimiter: passthrough
+    };
+});
+
+import { validatePasswordStrength, hashPassword, verifyPassword } from "../src/auth/password";
+import { logger } from "../src/utils/logger";
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+const TEST_SECRET = "integration-test-secret-key-that-is-definitely-32-chars-long!!";
+
+function mockUser(overrides: Partial<{ id: string; email: string; passwordHash: string | null; displayName: string | null; photoUrl: string | null; provider: string; emailVerified: boolean; emailVerificationToken: string | null }> = {}) {
+    return {
+        id: overrides.id ?? "user-1",
+        email: overrides.email ?? "test@example.com",
+        passwordHash: "passwordHash" in overrides ? overrides.passwordHash : "salt:hash",
+        displayName: overrides.displayName ?? "Test User",
+        photoUrl: overrides.photoUrl ?? null,
+        emailVerified: overrides.emailVerified ?? false,
+        emailVerificationToken: overrides.emailVerificationToken ?? null,
+        emailVerificationSentAt: null,
+        createdAt: new Date(),
+        updatedAt: new Date()
+    };
+}
+
+function mockRole(id: string, isAdmin = false) {
+    return { id,
+name: id.charAt(0).toUpperCase() + id.slice(1),
+isAdmin,
+defaultPermissions: null,
+collectionPermissions: null };
+}
+
+let mockAuthRepo: jest.Mocked<AuthRepository>;
+
+function createApp(opts: { authHooks?: AuthHooks } = {}) {
+    mockAuthRepo = {
+        getUserByEmail: jest.fn().mockResolvedValue(null),
+        getUserByIdentity: jest.fn().mockResolvedValue(null),
+        linkUserIdentity: jest.fn().mockResolvedValue(undefined),
+        getUserIdentities: jest.fn().mockResolvedValue([]),
+        getUserById: jest.fn().mockResolvedValue(null),
+        createUser: jest.fn().mockImplementation((data) =>
+            Promise.resolve(mockUser({ email: data.email,
+displayName: data.displayName,
+passwordHash: data.passwordHash }))
+        ),
+        listUsers: jest.fn().mockResolvedValue([]),
+        getUserRoles: jest.fn().mockResolvedValue([mockRole("editor")]),
+        getUserRoleIds: jest.fn().mockResolvedValue(["editor"]),
+        assignDefaultRole: jest.fn().mockResolvedValue(undefined),
+        setUserRoles: jest.fn().mockResolvedValue(undefined),
+        updateUser: jest.fn().mockImplementation((id, data) =>
+            Promise.resolve(mockUser({ id,
+...data }))
+        ),
+        deleteUser: jest.fn().mockResolvedValue(undefined),
+        updatePassword: jest.fn().mockResolvedValue(undefined),
+        setEmailVerified: jest.fn().mockResolvedValue(undefined),
+        setVerificationToken: jest.fn().mockResolvedValue(undefined),
+        getUserByVerificationToken: jest.fn().mockResolvedValue(null),
+        getUserWithRoles: jest.fn().mockImplementation(async (userId) => {
+            const user = mockUser({ id: userId });
+            return { user,
+roles: [mockRole("editor")] };
+        }),
+        createRefreshToken: jest.fn().mockResolvedValue(undefined),
+        findRefreshTokenByHash: jest.fn().mockResolvedValue(null),
+        deleteRefreshToken: jest.fn().mockResolvedValue(undefined),
+        deleteAllRefreshTokensForUser: jest.fn().mockResolvedValue(undefined),
+        listRefreshTokensForUser: jest.fn().mockResolvedValue([]),
+        deleteRefreshTokenById: jest.fn().mockResolvedValue(undefined),
+        createPasswordResetToken: jest.fn().mockResolvedValue(undefined),
+        findValidPasswordResetToken: jest.fn().mockResolvedValue(null),
+        markPasswordResetTokenUsed: jest.fn().mockResolvedValue(undefined),
+        deleteExpiredPasswordResetTokens: jest.fn().mockResolvedValue(undefined)
+    } as unknown as jest.Mocked<AuthRepository>;
+
+    // Password mocks
+    (validatePasswordStrength as jest.Mock).mockReturnValue({ valid: true,
+errors: [] });
+    (hashPassword as jest.Mock).mockResolvedValue("hashed-pw");
+    (verifyPassword as jest.Mock).mockResolvedValue(true);
+
+    const config: AuthModuleConfig = {
+        authRepo: mockAuthRepo,
+        allowRegistration: true,
+        authHooks: opts.authHooks
+    };
+
+    const app = new Hono<HonoEnv>();
+    app.onError(errorHandler);
+    app.route("/auth", createAuthRoutes(config));
+    return app;
+}
+
+function json(body: Record<string, unknown>) {
+    return {
+        method: "POST" as const,
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+    };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// TESTS
+// ═══════════════════════════════════════════════════════════════════════════
+
+describe("transformAuthResponse hook", () => {
+    beforeAll(() => {
+        configureJwt({ secret: TEST_SECRET,
+accessExpiresIn: "1h" });
+    });
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    // ── Registration ────────────────────────────────────────────────────
+
+    describe("POST /auth/register", () => {
+        it("calls transformAuthResponse with the response and 'register' method", async () => {
+            const transformHook = jest.fn(async (response: AuthResponsePayload) => ({
+                ...response,
+                tokens: { ...response.tokens, firebaseToken: "custom-firebase-token" }
+            }));
+            const app = createApp({ authHooks: { transformAuthResponse: transformHook } });
+
+            const res = await app.request("/auth/register", json({ email: "new@test.com", password: "StrongPass1" }));
+            expect(res.status).toBe(201);
+            const body = await res.json() as Record<string, unknown>;
+            const tokens = body.tokens as Record<string, unknown>;
+
+            // Verify the hook was called
+            expect(transformHook).toHaveBeenCalledTimes(1);
+
+            // Verify context
+            const context = transformHook.mock.calls[0][1] as TransformAuthResponseContext;
+            expect(context.method).toBe("register");
+            expect(context.userId).toBeTruthy();
+            expect(context.request).toBeInstanceOf(Request);
+
+            // Verify the custom field was injected
+            expect(tokens.firebaseToken).toBe("custom-firebase-token");
+            // Original fields still present
+            expect(tokens.accessToken).toBeTruthy();
+            expect(tokens.refreshToken).toBeTruthy();
+        });
+    });
+
+    // ── Login ────────────────────────────────────────────────────────────
+
+    describe("POST /auth/login", () => {
+        it("calls transformAuthResponse with 'login' method", async () => {
+            const transformHook = jest.fn(async (response: AuthResponsePayload) => ({
+                ...response,
+                tokens: { ...response.tokens, externalToken: "ext-123" }
+            }));
+            const app = createApp({ authHooks: { transformAuthResponse: transformHook } });
+
+            // Setup: user exists
+            mockAuthRepo.getUserByEmail.mockResolvedValueOnce(mockUser());
+
+            const res = await app.request("/auth/login", json({ email: "test@example.com", password: "StrongPass1" }));
+            expect(res.status).toBe(200);
+            const body = await res.json() as Record<string, unknown>;
+            const tokens = body.tokens as Record<string, unknown>;
+
+            expect(transformHook).toHaveBeenCalledTimes(1);
+            const context = transformHook.mock.calls[0][1] as TransformAuthResponseContext;
+            expect(context.method).toBe("login");
+            expect(tokens.externalToken).toBe("ext-123");
+        });
+    });
+
+    // ── Refresh ──────────────────────────────────────────────────────────
+
+    describe("POST /auth/refresh", () => {
+        it("calls transformAuthResponse with 'refresh' method (tokens-only response)", async () => {
+            const transformHook = jest.fn(async (response: AuthResponsePayload) => ({
+                ...response,
+                tokens: { ...response.tokens, refreshedExternalToken: "refreshed-ext" }
+            }));
+            const app = createApp({ authHooks: { transformAuthResponse: transformHook } });
+
+            // Setup: valid refresh token exists
+            const rawRefreshToken = "a".repeat(80);
+            const hashedToken = hashRefreshToken(rawRefreshToken);
+            mockAuthRepo.findRefreshTokenByHash.mockResolvedValueOnce({
+                id: "rt-1",
+                userId: "user-1",
+                tokenHash: hashedToken,
+                expiresAt: new Date(Date.now() + 86400000), // 1 day from now
+                createdAt: new Date(),
+                userAgent: "test",
+                ipAddress: "127.0.0.1"
+            });
+            mockAuthRepo.getUserRoleIds.mockResolvedValueOnce(["editor"]);
+
+            const res = await app.request("/auth/refresh", json({ refreshToken: rawRefreshToken }));
+            expect(res.status).toBe(200);
+            const body = await res.json() as Record<string, unknown>;
+            const tokens = body.tokens as Record<string, unknown>;
+
+            expect(transformHook).toHaveBeenCalledTimes(1);
+
+            // Verify refresh context
+            const hookResponse = transformHook.mock.calls[0][0] as AuthResponsePayload;
+            const context = transformHook.mock.calls[0][1] as TransformAuthResponseContext;
+            expect(context.method).toBe("refresh");
+            expect(hookResponse.user).toBeUndefined(); // refresh has no user
+            expect(tokens.refreshedExternalToken).toBe("refreshed-ext");
+        });
+    });
+
+    // ── Error handling ───────────────────────────────────────────────────
+
+    describe("error handling", () => {
+        it("returns untransformed response when hook throws", async () => {
+            const transformHook = jest.fn(async () => {
+                throw new Error("External service down");
+            });
+            const app = createApp({ authHooks: { transformAuthResponse: transformHook } });
+
+            const res = await app.request("/auth/register", json({ email: "new@test.com", password: "StrongPass1" }));
+            expect(res.status).toBe(201);
+            const body = await res.json() as Record<string, unknown>;
+            const tokens = body.tokens as Record<string, unknown>;
+            const user = body.user as Record<string, unknown>;
+
+            // Response is still valid (untransformed fallback)
+            expect(tokens.accessToken).toBeTruthy();
+            expect(tokens.refreshToken).toBeTruthy();
+            expect(user.email).toBe("new@test.com");
+
+            // Error was logged
+            expect(logger.error).toHaveBeenCalledWith(
+                "[AuthHooks] transformAuthResponse error",
+                expect.objectContaining({ error: "External service down" })
+            );
+        });
+    });
+
+    // ── Opt-in behavior ──────────────────────────────────────────────────
+
+    describe("opt-in behavior", () => {
+        it("does not alter response when hook is not provided", async () => {
+            const app = createApp(); // no hooks
+
+            const res = await app.request("/auth/register", json({ email: "new@test.com", password: "StrongPass1" }));
+            expect(res.status).toBe(201);
+            const body = await res.json() as Record<string, unknown>;
+            const tokens = body.tokens as Record<string, unknown>;
+            const user = body.user as Record<string, unknown>;
+
+            // Standard response, no extra fields
+            expect(tokens.accessToken).toBeTruthy();
+            expect(tokens.refreshToken).toBeTruthy();
+            expect(user.email).toBe("new@test.com");
+            expect(Object.keys(tokens as object)).toEqual(
+                expect.arrayContaining(["accessToken", "refreshToken", "accessTokenExpiresAt"])
+            );
+        });
+    });
+});

package/vite.config.ts

@@ -53,6 +53,11 @@ export default defineConfig(() => ({
         sourcemap: true,
         rollupOptions: {
             external: isExternal,
+            onwarn(warning, warn) {
+                if (warning.code === "MISSING_GLOBAL_NAME") return;
+                if (warning.code === "INEFFECTIVE_DYNAMIC_IMPORT") return;
+                warn(warning);
+            },
             output: {
                 banner: 'import { createRequire as __createRequire } from "module"; import process from "process"; const require = __createRequire(import.meta.url);',
                 globals: {

package/build-errors.txt

@@ -1,52 +0,0 @@
-
-> @rebasepro/server-core@0.0.1 build /Users/francesco/rebase/packages/server-core
-> vite build && tsc --emitDeclarationOnly -p tsconfig.prod.json
-
-vite v5.4.21 building for production...
-transforming...
-✓ 1641 modules transformed.
-rendering chunks...
-computing gzip size...
-dist/index.es.js            1.68 kB │ gzip:   0.80 kB │ map:     0.09 kB
-dist/index-CvlusawO.js      8.86 kB │ gzip:   2.11 kB │ map:    16.79 kB
-dist/index-BGGPU0RK.js  1,946.14 kB │ gzip: 411.28 kB │ map: 4,292.57 kB
-dist/index.umd.js  2,070.48 kB │ gzip: 419.31 kB │ map: 4,326.51 kB
-✓ built in 2.97s
-src/api/graphql/graphql-schema-generator.ts(65,34): error TS18046: 'source' is of type 'unknown'.
-src/api/graphql/graphql-schema-generator.ts(72,51): error TS18046: 'source' is of type 'unknown'.
-src/api/graphql/graphql-schema-generator.ts(136,13): error TS2322: Type 'Record<string, unknown>' is not assignable to type 'ThunkObjMap<GraphQLInputFieldConfig>'.
-src/api/graphql/graphql-schema-generator.ts(178,17): error TS2322: Type '(_: unknown, args: any, context: { driver: DataDriver; }) => Promise<Entity<Record<string, unknown>> | undefined>' is not assignable to type 'GraphQLFieldResolver<unknown, unknown, any, unknown>'.
-  Types of parameters 'context' and 'context' are incompatible.
-    Type 'unknown' is not assignable to type '{ driver: DataDriver; }'.
-src/api/graphql/graphql-schema-generator.ts(198,17): error TS2322: Type '(_: unknown, args: any, context: { driver: DataDriver; }) => Promise<Entity<Record<string, unknown>>[]>' is not assignable to type 'GraphQLFieldResolver<unknown, unknown, any, unknown>'.
-  Types of parameters 'context' and 'context' are incompatible.
-    Type 'unknown' is not assignable to type '{ driver: DataDriver; }'.
-src/api/graphql/graphql-schema-generator.ts(249,17): error TS2322: Type '(_: unknown, args: any, context: { driver: DataDriver; }) => Promise<Entity<Record<string, unknown>>>' is not assignable to type 'GraphQLFieldResolver<unknown, unknown, any, unknown>'.
-  Types of parameters 'context' and 'context' are incompatible.
-    Type 'unknown' is not assignable to type '{ driver: DataDriver; }'.
-src/api/graphql/graphql-schema-generator.ts(269,17): error TS2322: Type '(_: unknown, args: any, context: { driver: DataDriver; }) => Promise<Entity<Record<string, unknown>>>' is not assignable to type 'GraphQLFieldResolver<unknown, unknown, any, unknown>'.
-  Types of parameters 'context' and 'context' are incompatible.
-    Type 'unknown' is not assignable to type '{ driver: DataDriver; }'.
-src/api/graphql/graphql-schema-generator.ts(288,17): error TS2322: Type '(_: unknown, args: any, context: { driver: DataDriver; }) => Promise<boolean>' is not assignable to type 'GraphQLFieldResolver<unknown, unknown, any, unknown>'.
-  Types of parameters 'context' and 'context' are incompatible.
-    Type 'unknown' is not assignable to type '{ driver: DataDriver; }'.
-src/api/rest/api-generator.ts(90,63): error TS18046: 'entities' is of type 'unknown'.
-src/collections/BackendCollectionRegistry.ts(18,9): error TS2322: Type '{}[]' is not assignable to type 'string[]'.
-  Type '{}' is not assignable to type 'string'.
-src/functions/function-loader.ts(10,15): error TS2344: Type 'unknown' does not satisfy the constraint 'Env'.
-src/functions/function-routes.ts(27,37): error TS2345: Argument of type 'Hono<unknown, BlankSchema, "/">' is not assignable to parameter of type 'Hono<Env, BlankSchema, "/", "/">'.
-  The types of 'get(...).get' are incompatible between these types.
-    Type 'HandlerInterface<unknown, "get", BlankSchema, "/", any>' is not assignable to type 'HandlerInterface<Env, "get", BlankSchema, "/", any>'.
-      Types of parameters 'handlers' and 'handlers' are incompatible.
-        Type 'H<Env, any, any, any>' is not assignable to type 'H<unknown, any, any, any>'.
-          Type 'Handler<Env, any, any, any>' is not assignable to type 'H<unknown, any, any, any>'.
-            Type 'Handler<Env, any, any, any>' is not assignable to type 'Handler<unknown, any, any, any>'.
-              Types of parameters 'c' and 'c' are incompatible.
-                Type 'Context<unknown, any, any>' is not assignable to type 'Context<Env, any, any>'.
-                  Types of property 'env' are incompatible.
-                    Type 'unknown' is not assignable to type 'object | undefined'.
-src/history/history-routes.ts(48,30): error TS18046: 'historyService' is of type 'unknown'.
-src/history/history-routes.ts(87,36): error TS18046: 'historyService' is of type 'unknown'.
-src/serve-spa.ts(38,36): error TS2344: Type 'unknown' does not satisfy the constraint 'Env'.
-src/storage/LocalStorageController.ts(346,33): error TS2339: Property 'code' does not exist on type '{}'.
- ELIFECYCLE  Command failed with exit code 2.

package/dist/api/ast-schema-editor.d.ts

@@ -1,21 +0,0 @@
-export declare class AstSchemaEditor {
-    private project;
-    private collectionsDir;
-    constructor(collectionsDir: string);
-    /**
-     * Sanitize collectionId to prevent path traversal attacks.
-     * Only allows alphanumeric characters, underscores, and hyphens.
-     */
-    private sanitizeCollectionId;
-    /**
-     * Resolve a file path and ensure it falls within the collectionsDir.
-     */
-    private safePath;
-    private getCollectionFile;
-    private getCollectionObject;
-    private convertJsonToAstString;
-    saveProperty(collectionId: string, propertyKey: string, propertyConfig: Record<string, unknown>): Promise<void>;
-    deleteProperty(collectionId: string, propertyKey: string): Promise<void>;
-    saveCollection(collectionId: string, collectionData: Record<string, unknown>): Promise<void>;
-    deleteCollection(collectionId: string): Promise<void>;
-}

package/dist/api/collections_for_test/callbacks_test_collection.d.ts

@@ -1,2 +0,0 @@
-import { PostgresCollection } from "@rebasepro/types";
-export declare const callbacksTestCollection: PostgresCollection;

package/dist/api/errors.d.ts

@@ -1,53 +0,0 @@
-import type { ErrorHandler } from "hono";
-import type { HonoEnv } from "./types";
-/**
- * Standardized API error class.
- * Throw this from any route handler — the errorHandler middleware
- * will format it into `{ error: { message, code, details? } }`.
- */
-export declare class ApiError extends Error {
-    readonly statusCode: number;
-    readonly code: string;
-    readonly details?: unknown;
-    constructor(statusCode: number, code: string, message: string, details?: unknown);
-    static badRequest(message: string, code?: string, details?: unknown): ApiError;
-    static unauthorized(message: string, code?: string): ApiError;
-    static forbidden(message: string, code?: string): ApiError;
-    static notFound(message: string, code?: string): ApiError;
-    static conflict(message: string, code?: string): ApiError;
-    static internal(message: string, code?: string): ApiError;
-    static serviceUnavailable(message: string, code?: string): ApiError;
-}
-/**
- * Canonical error response shape:
- * `{ error: { message: string, code: string, details?: unknown } }`
- */
-export interface ErrorResponse {
-    error: {
-        message: string;
-        code: string;
-        details?: unknown;
-        /** Request correlation ID for tracing (echoes X-Request-ID). */
-        requestId?: string;
-    };
-}
-/**
- * General shape of errors that flow through the API error handler.
- * Extends Error with optional HTTP status, error code, and details.
- */
-export interface RebaseApiError extends Error {
-    statusCode?: number;
-    code?: string;
-    details?: unknown;
-}
-/**
- * Type guard for errors that carry optional API metadata (statusCode, code, details).
- * Returns true for any Error instance — the optional properties are then
- * checked via normal property access.
- */
-export declare function isRebaseApiError(error: unknown): error is RebaseApiError;
-/**
- * Hono error-handling middleware (`app.onError`).
- * Converts any error into the canonical `{ error: { message, code } }` shape.
- */
-export declare const errorHandler: ErrorHandler<HonoEnv>;

package/dist/api/graphql/graphql-schema-generator.d.ts

@@ -1,35 +0,0 @@
-import { GraphQLSchema } from "graphql";
-import { DataDriver, EntityCollection } from "@rebasepro/types";
-/**
- * Lightweight GraphQL schema generator that leverages existing DataDriver
- * No duplication - uses your existing data layer and services
- */
-export declare class GraphQLSchemaGenerator {
-    private collections;
-    private driver;
-    private typeRegistry;
-    private inputTypeRegistry;
-    constructor(collections: EntityCollection[], driver: DataDriver);
-    /**
-     * Generate complete GraphQL schema using existing DataDriver
-     */
-    generateSchema(): GraphQLSchema;
-    /**
-     * Create GraphQL type for an entity collection
-     */
-    private createEntityType;
-    private convertPropertyToField;
-    private createInputType;
-    private convertPropertyToInputType;
-    /**
-     * Create Query type using existing DataDriver methods
-     */
-    private createQueryType;
-    /**
-     * Create Mutation type using existing DataDriver methods
-     */
-    private createMutationType;
-    private getTypeName;
-    private getSingleQueryName;
-    private getListQueryName;
-}

package/dist/api/graphql/index.d.ts

@@ -1 +0,0 @@
-export * from "./graphql-schema-generator";

package/dist/api/index.d.ts

@@ -1,9 +0,0 @@
-/**
- * API generation infrastructure for Rebase
- * Automatically generates GraphQL and REST APIs from EntityCollection definitions
- */
-export * from "./graphql";
-export * from "./rest";
-export * from "./types";
-export * from "./errors";
-export * from "./server";

package/dist/api/logs-routes.d.ts

@@ -1,37 +0,0 @@
-import { Hono } from "hono";
-import type { MiddlewareHandler } from "hono";
-import type { HonoEnv } from "./types";
-export interface LogEntry {
-    id: string;
-    timestamp: string;
-    level: "debug" | "info" | "warn" | "error";
-    source: "api" | "auth" | "storage" | "realtime" | "system";
-    message: string;
-    metadata?: Record<string, unknown>;
-}
-declare class LogRingBuffer {
-    private buffer;
-    private maxSize;
-    private idCounter;
-    constructor(maxSize?: number);
-    push(entry: Omit<LogEntry, "id">): void;
-    query(options: {
-        level?: string;
-        source?: string;
-        search?: string;
-        limit?: number;
-        offset?: number;
-        since?: string;
-    }): {
-        entries: LogEntry[];
-        total: number;
-    };
-    getLatest(count?: number): LogEntry[];
-}
-export declare const logBuffer: LogRingBuffer;
-/** Add a log entry */
-export declare function addLog(level: LogEntry["level"], source: LogEntry["source"], message: string, metadata?: Record<string, unknown>): void;
-/** Hono middleware to log API requests */
-export declare function logMiddleware(): MiddlewareHandler<HonoEnv>;
-declare const app: Hono<HonoEnv, import("hono/types").BlankSchema, "/">;
-export default app;

package/dist/api/openapi-generator.d.ts

@@ -1,16 +0,0 @@
-import { EntityCollection } from "@rebasepro/types";
-/**
- * OpenAPI 3.0.3 specification generator.
- *
- * Produces a spec that exactly mirrors the REST API consumed by the
- * Rebase SDK client (`@rebasepro/client`).
- *
- * Routes are mounted at `{basePath}/data/{slug}` by `initializeRebaseBackend`.
- */
-export interface OpenApiGeneratorOptions {
-    /** Base path for the API (e.g. "/api"). Defaults to "/api". */
-    basePath?: string;
-    /** Whether auth is enabled on data routes. Defaults to true. */
-    requireAuth?: boolean;
-}
-export declare function generateOpenApiSpec(collections: EntityCollection[], options?: OpenApiGeneratorOptions): Record<string, unknown>;

package/dist/api/rest/api-generator.d.ts

@@ -1,88 +0,0 @@
-import { Hono } from "hono";
-import { AuthAdapter, DataDriver, EntityCollection, DataHooks } from "@rebasepro/types";
-import { HonoEnv } from "../types";
-/**
- * Lightweight REST API generator that leverages existing Rebase DataDriver.
- * Supports `include` query parameter for eager-loading relations via Drizzle.
- */
-export declare class RestApiGenerator {
-    private collections;
-    private router;
-    private driver;
-    private dataHooks?;
-    private authAdapter?;
-    constructor(collections: EntityCollection[], driver: DataDriver, dataHooks?: DataHooks, authAdapter?: AuthAdapter);
-    /** Build a BackendHookContext from a Hono context */
-    private buildHookContext;
-    /**
-     * Generate REST routes using existing DataDriver
-     */
-    generateRoutes(): Hono<HonoEnv>;
-    /**
-     * Check API key permissions for a collection operation.
-     * Throws 403 if the key doesn't have the required permission.
-     * No-ops if the request is not authenticated via an API key.
-     */
-    private enforceApiKeyPermission;
-    /**
-     * Get the request-scoped driver. Throws if none is set — never falls
-     * back to the unscoped `this.driver` to avoid bypassing RLS/auth.
-     */
-    private getScopedDriver;
-    /**
-     * Get the typed RestFetchService from a driver if it exposes one (for include support).
-     */
-    private getFetchService;
-    /**
-     * Create REST routes for a collection using existing Rebase patterns
-     */
-    private createCollectionRoutes;
-    /**
-     * 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;
-    /**
-     * Format successful API response - flattened for traditional REST API
-     */
-    private formatResponse;
-    /**
-     * Flatten Rebase entity structure to traditional REST format
-     */
-    private flattenEntity;
-    /**
-     * Fetch raw collection data without Entity wrapper (fallback for non-Postgres)
-     */
-    private fetchRawCollection;
-    /**
-     * Count raw entities for a collection
-     */
-    private countRawEntities;
-    /**
-     * Fetch single entity raw data without Entity wrapper (fallback)
-     */
-    private fetchRawEntity;
-    /**
-     * Apply data.afterRead hook to a single entity.
-     * Returns the transformed entity, or null to filter it out.
-     */
-    private applyAfterRead;
-    /**
-     * Apply data.afterRead hook to an array of entities, filtering out nulls.
-     */
-    private applyAfterReadBatch;
-}

package/dist/api/rest/index.d.ts

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

package/dist/api/rest/query-parser.d.ts

@@ -1,11 +0,0 @@
-import type { LogicalCondition, FilterCondition } from "@rebasepro/types";
-import { QueryOptions } from "../types";
-/**
- * Map PostgREST-style operators to Rebase WhereFilterOp
- */
-export declare function mapOperator(op: string): string | null;
-export declare function parseLogicalString(str: string): FilterCondition | LogicalCondition;
-/**
- * Parse query parameters into QueryOptions
- */
-export declare function parseQueryOptions(query: Record<string, unknown>): QueryOptions;

package/dist/api/schema-editor-routes.d.ts

@@ -1,3 +0,0 @@
-import { Hono } from "hono";
-import { HonoEnv } from "./types";
-export declare function createSchemaEditorRoutes(collectionsDir: string): Hono<HonoEnv>;