@rebasepro/server-core 0.3.0 → 0.5.0

package/README.md

@@ -1,40 +1,77 @@
-# @rebasepro/backend
+# @rebasepro/server-core
 
-PostgreSQL and Drizzle ORM backend implementation for Rebase.
-
-This package provides a complete backend solution for Rebase applications using PostgreSQL as the database and Drizzle ORM for type-safe database operations.
+Database-agnostic backend core for Rebase.
 
 ## Installation
 
 ```bash
-npm install @rebasepro/backend @rebasepro/core
+pnpm add @rebasepro/server-core
 ```
 
-## Usage
+## What This Package Does
 
-```typescript
-import { createBackend } from "@rebasepro/backend";
+This is the central orchestrator for any Rebase backend. It provides the framework-level plumbing — HTTP routing (Hono), authentication middleware, storage, email, cron jobs, custom functions, and the REST/GraphQL API generator — without being coupled to any specific database. Database implementations are plugged in via driver packages like `@rebasepro/server-postgresql` or `@rebasepro/server-mongodb`.
 
-const backend = createBackend({
-  connectionString: "postgresql://user:password@localhost:5432/database",
-  schema: "public",
-  debug: true
-});
-```
+## Key Exports
+
+| Export | Description |
+|--------|-------------|
+| `initializeRebaseBackend(config)` | Main entry point. Wires up drivers, auth, storage, API routes, cron, and custom functions. Returns a `RebaseBackendInstance`. |
+| `rebase` | Server-side singleton (`RebaseClient`). Available after init. Admin-level access to data, auth, email, and storage. |
+| `loadEnv()` | Validates `process.env` against the Rebase env schema (Zod). Auto-generates dev secrets. Supports `extend` for custom vars. |
+| `serveSPA(app, config)` | Mounts SPA static-file serving + index.html fallback on a Hono app. |
+| `RebaseBackendConfig` | Config type for `initializeRebaseBackend`. |
+| `RebaseAuthConfig` | Auth config type (JWT, OAuth providers, hooks, service key). |
+| `RebaseBackendInstance` | Return type — includes `driver`, `healthCheck()`, `shutdown()`, `cronScheduler`, `storageController`, etc. |
+| `RebaseEnv` | Zod-inferred type of validated environment variables. |
+| `z` | Re-exported Zod instance for extending `loadEnv`. |
+| `_setRebaseMock` / `_resetRebaseMock` | Test helpers to mock the `rebase` singleton (NODE_ENV=test only). |
 
-## Features
+Also re-exports all abstract interfaces (`DatabaseAdapter`, `AuthAdapter`, `DataDriver`, etc.), API types (`HonoEnv`, `ApiConfig`), auth module, email module, storage module, history module, cron module, custom functions, logging utilities, and driver registry.
 
-- PostgreSQL database support
-- Drizzle ORM integration
-- Type-safe database operations
-- Full Rebase compatibility
-- Migration support
-- Connection pooling
+## Quick Start
 
-## Development
+```typescript
+import { serve } from "@hono/node-server";
+import { Hono } from "hono";
+import { initializeRebaseBackend, loadEnv, serveSPA } from "@rebasepro/server-core";
+import { createPostgresAdapter } from "@rebasepro/server-postgresql";
 
-This package is part of the Rebase monorepo. For development instructions, see the main repository README.
+// 1. Load and validate environment
+const env = loadEnv();
+
+// 2. Create Hono app + HTTP server
+const app = new Hono();
+const server = serve({ fetch: app.fetch, port: env.PORT });
+
+// 3. Initialize Rebase
+const backend = await initializeRebaseBackend({
+  app,
+  server,
+  database: createPostgresAdapter({ connection: db, schema }),
+  collections: myCollections,
+  auth: {
+    collection: defaultUsersCollection,
+    jwtSecret: env.JWT_SECRET,
+    allowRegistration: env.ALLOW_REGISTRATION,
+    serviceKey: env.REBASE_SERVICE_KEY,
+    google: { clientId: env.GOOGLE_CLIENT_ID },
+  },
+  storage: { type: "s3", bucket: env.S3_BUCKET },
+  functionsDir: "./functions",
+  cronsDir: "./crons",
+});
+
+// 4. Optionally serve a frontend SPA
+serveSPA(app, { frontendPath: "./frontend/dist" });
+```
 
-## License
+## Related Packages
 
-MIT
+| Package | Role |
+|---------|------|
+| `@rebasepro/server-postgresql` | PostgreSQL database driver (Drizzle ORM) |
+| `@rebasepro/server-mongodb` | MongoDB database driver |
+| `@rebasepro/types` | Shared type definitions (`DataDriver`, `EntityCollection`, etc.) |
+| `@rebasepro/client` | Client SDK used internally by the `rebase` singleton |
+| `@rebasepro/common` | Shared utilities and default collections |

package/dist/common/src/collections/default-collections.d.ts

@@ -1,12 +1,9 @@
-import { PostgresCollection } from "@rebasepro/types";
+import type { PostgresCollection } from "@rebasepro/types";
 /**
- * Default users collection definition.
+ * Default users collection.
  *
- * Shared between the admin UI (for navigation/display) and the backend
- * (for schema generation). Both consumers prepend this to the developer's
- * collections array and rely on generic slug-based deduplication
- * (Map keyed by slug, last-write-wins) so that developer-defined
- * collections with the same slug override this default — no hardcoded
- * string checks required.
+ * Prepended to the developer's collections array by the admin and server.
+ * Slug-based dedup (Map keyed by slug, last-write-wins) lets developers
+ * override by defining their own collection with `slug: "users"`.
  */
 export declare const defaultUsersCollection: PostgresCollection;

package/dist/common/src/data/query_builder.d.ts

@@ -1,4 +1,7 @@
-import { FindResponse, CollectionAccessor, QueryBuilderInterface, FilterOperator } from "@rebasepro/types";
+import { FindResponse, CollectionAccessor, QueryBuilderInterface, FilterOperator, LogicalCondition, WhereValue, FilterCondition } from "@rebasepro/types";
+export declare function or(...conditions: (FilterCondition | LogicalCondition)[]): LogicalCondition;
+export declare function and(...conditions: (FilterCondition | LogicalCondition)[]): LogicalCondition;
+export declare function cond(column: string, operator: FilterOperator, value: unknown): FilterCondition;
 export declare class QueryBuilder<M extends Record<string, unknown> = Record<string, unknown>> implements QueryBuilderInterface<M> {
     private collection;
     private params;
@@ -8,7 +11,8 @@ export declare class QueryBuilder<M extends Record<string, unknown> = Record<str
      * @example
      * client.collection('users').where('age', '>=', 18).find()
      */
-    where(column: keyof M & string, operator: FilterOperator, value: unknown): this;
+    where<K extends keyof M & string>(column: K, operator: FilterOperator, value: WhereValue<M[K]>): this;
+    where(logicalCondition: LogicalCondition): this;
     /**
      * Order the results by a specific column.
      * @example

package/dist/common/src/util/permissions.d.ts

@@ -1,6 +1,14 @@
-import { AuthController, Entity, EntityCollection, User } from "@rebasepro/types";
-export declare function checkOperation<M extends Record<string, unknown>, USER extends User>(collection: EntityCollection<M>, authController: AuthController<USER>, entity: Entity<M> | null, targetOperation: "select" | "insert" | "update" | "delete"): boolean;
-export declare function canReadCollection<M extends Record<string, unknown>, USER extends User>(collection: EntityCollection<M>, authController: AuthController<USER>): boolean;
-export declare function canEditEntity<M extends Record<string, unknown>, USER extends User>(collection: EntityCollection<M>, authController: AuthController<USER>, path: string, entity: Entity<M> | null): boolean;
-export declare function canCreateEntity<M extends Record<string, unknown>, USER extends User>(collection: EntityCollection<M>, authController: AuthController<USER>, path: string, entity: Entity<M> | null): boolean;
-export declare function canDeleteEntity<M extends Record<string, unknown>, USER extends User>(collection: EntityCollection<M>, authController: AuthController<USER>, path: string, entity: Entity<M> | null): boolean;
+import { Entity, EntityCollection, User } from "@rebasepro/types";
+/**
+ * Minimal auth context for permission checking.
+ * Only requires the user object — avoids forcing callers to construct
+ * a full AuthController just to check permissions.
+ */
+export interface AuthContext<USER extends User = User> {
+    user: USER | null;
+}
+export declare function checkOperation<M extends Record<string, unknown>, USER extends User>(collection: EntityCollection<M>, authContext: AuthContext<USER>, entity: Entity<M> | null, targetOperation: "select" | "insert" | "update" | "delete"): boolean;
+export declare function canReadCollection<M extends Record<string, unknown>, USER extends User>(collection: EntityCollection<M>, authContext: AuthContext<USER>): boolean;
+export declare function canEditEntity<M extends Record<string, unknown>, USER extends User>(collection: EntityCollection<M>, authContext: AuthContext<USER>, path: string, entity: Entity<M> | null): boolean;
+export declare function canCreateEntity<M extends Record<string, unknown>, USER extends User>(collection: EntityCollection<M>, authContext: AuthContext<USER>, path: string, entity: Entity<M> | null): boolean;
+export declare function canDeleteEntity<M extends Record<string, unknown>, USER extends User>(collection: EntityCollection<M>, authContext: AuthContext<USER>, path: string, entity: Entity<M> | null): boolean;