@rebasepro/server-core 0.0.1-canary.09e5ec5

package/dist/server-core/src/api/ast-schema-editor.d.ts

@@ -0,0 +1,21 @@
+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/server-core/src/api/collections_for_test/callbacks_test_collection.d.ts

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

package/dist/server-core/src/api/errors.d.ts

@@ -0,0 +1,35 @@
+import { ErrorHandler } from "hono";
+/**
+ * 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;
+    };
+}
+/**
+ * Hono error-handling middleware (`app.onError`).
+ * Converts any error into the canonical `{ error: { message, code } }` shape.
+ */
+export declare const errorHandler: ErrorHandler;

package/dist/server-core/src/api/graphql/graphql-schema-generator.d.ts

@@ -0,0 +1,35 @@
+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/server-core/src/api/graphql/index.d.ts

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

package/dist/server-core/src/api/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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/server-core/src/api/openapi-generator.d.ts

@@ -0,0 +1,16 @@
+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/server-core/src/api/rest/api-generator.d.ts

@@ -0,0 +1,64 @@
+import { Hono } from "hono";
+import { DataDriver, EntityCollection } 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;
+    constructor(collections: EntityCollection[], driver: DataDriver);
+    /**
+     * Generate REST routes using existing DataDriver
+     */
+    generateRoutes(): Hono<HonoEnv>;
+    /**
+     * Get the EntityFetchService 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;
+}

package/dist/server-core/src/api/rest/index.d.ts

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

package/dist/server-core/src/api/rest/query-parser.d.ts

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

package/dist/server-core/src/api/schema-editor-routes.d.ts

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

package/dist/server-core/src/api/server.d.ts

@@ -0,0 +1,40 @@
+import { Hono } from "hono";
+import { DataDriver } from "@rebasepro/types";
+import { ApiConfig, HonoEnv } from "./types";
+/**
+ * Simplified API server that leverages existing Rebase infrastructure
+ * Can be used standalone or mounted on existing Hono app
+ */
+export declare class RebaseApiServer {
+    private app;
+    private router;
+    private config;
+    private driver;
+    private constructor();
+    /**
+     * Factory method to create an asynchronously initialized ApiServer instance
+     */
+    static create(config: ApiConfig & {
+        driver: DataDriver;
+    }): Promise<RebaseApiServer>;
+    /**
+     * Setup Hono middleware
+     */
+    private setupMiddleware;
+    /**
+     * Setup API routes using existing services
+     */
+    private setupRoutes;
+    /**
+     * Get the Hono router with all API routes
+     */
+    getRouter(): Hono<HonoEnv>;
+    /**
+     * Get the standalone Hono app
+     */
+    getApp(): Hono<HonoEnv>;
+    /**
+     * Start the server (standalone mode) via @hono/node-server
+     */
+    listen(port?: number, callback?: () => void): void;
+}

package/dist/server-core/src/api/types.d.ts

@@ -0,0 +1,90 @@
+import { EntityCollection } from "@rebasepro/types";
+import { AuthResult } from "../auth/middleware";
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { DataDriver } from "@rebasepro/types";
+/**
+ * Hono Environment Variables
+ * Passed to generic Hono<HonoEnv> to type `c.get()`
+ */
+export type HonoEnv = {
+    Variables: {
+        user?: AuthResult | {
+            userId?: string;
+            roles?: string[];
+        };
+        driver?: DataDriver;
+    };
+};
+/**
+ * Configuration for API generation
+ */
+/**
+ * Configuration for API generation
+ */
+export interface ApiConfig {
+    collections?: EntityCollection[];
+    collectionsDir?: string;
+    basePath?: string;
+    enableGraphQL?: boolean;
+    enableREST?: boolean;
+    cors?: {
+        origin?: string | string[] | boolean;
+        credentials?: boolean;
+    };
+    /** Whether auth is required for API endpoints (default: true) */
+    requireAuth?: boolean;
+    /** Optional custom validator for authentication */
+    authValidator?: (c: import("hono").Context<import("./types").HonoEnv>) => Promise<AuthResult>;
+    pagination?: {
+        defaultLimit: number;
+        maxLimit: number;
+    };
+}
+/**
+ * Context passed to resolvers and handlers
+ */
+export interface ApiContext {
+    user?: AuthResult;
+    collections: Map<string, EntityCollection>;
+    db: NodePgDatabase;
+}
+/**
+ * Standard API response format
+ */
+export interface ApiResponse<T = unknown> {
+    data?: T;
+    error?: {
+        message: string;
+        code?: string;
+        details?: unknown;
+    };
+    meta?: {
+        total?: number;
+        page?: number;
+        limit?: number;
+        hasMore?: boolean;
+    };
+}
+/**
+ * Query options for API endpoints
+ */
+export interface QueryOptions {
+    limit?: number;
+    offset?: number;
+    where?: Record<string, unknown>;
+    orderBy?: Array<{
+        field: string;
+        direction: "asc" | "desc";
+    }>;
+    include?: string[];
+    /** Columns to return in the response (field-level selection) */
+    fields?: string[];
+}
+/**
+ * Relation resolution configuration
+ */
+export interface RelationConfig {
+    relationName: string;
+    depth?: number;
+    include?: string[];
+}

package/dist/server-core/src/auth/admin-routes.d.ts

@@ -0,0 +1,16 @@
+import { Hono } from "hono";
+import { AuthModuleConfig } from "./routes";
+interface AdminRouteOptions extends AuthModuleConfig {
+    serviceKey?: string;
+    /**
+     * Callback to persistently mark bootstrap as completed.
+     * Invoked after the first admin user is promoted via POST /admin/bootstrap.
+     */
+    setBootstrapCompleted?: () => Promise<void>;
+}
+import { HonoEnv } from "../api/types";
+/**
+ * Create admin routes for user and role management
+ */
+export declare function createAdminRoutes(config: AdminRouteOptions): Hono<HonoEnv>;
+export {};

package/dist/server-core/src/auth/apple-oauth.d.ts

@@ -0,0 +1,30 @@
+import type { OAuthProvider } from "./interfaces";
+/**
+ * Creates an Apple Sign In OAuth Provider integration.
+ *
+ * Apple requires a client secret that is a signed JWT, regenerated on each
+ * token exchange (valid up to 6 months). This provider handles that automatically.
+ *
+ * Required Apple Developer configuration:
+ * - Services ID (clientId)
+ * - Key ID from the private key registered with Apple
+ * - Team ID from Apple Developer account
+ * - Private key (.p8 file contents) downloaded from Apple Developer portal
+ */
+export declare function createAppleProvider(config: {
+    clientId: string;
+    teamId: string;
+    keyId: string;
+    /** The raw PEM contents of the .p8 private key file */
+    privateKey: string;
+}): OAuthProvider<{
+    code: string;
+    redirectUri: string;
+    user?: {
+        name?: {
+            firstName?: string;
+            lastName?: string;
+        };
+        email?: string;
+    };
+}>;

package/dist/server-core/src/auth/bitbucket-oauth.d.ts

@@ -0,0 +1,11 @@
+import type { OAuthProvider } from "./interfaces";
+/**
+ * Creates a Bitbucket OAuth Provider integration (OAuth 2.0 consumer).
+ */
+export declare function createBitbucketProvider(config: {
+    clientId: string;
+    clientSecret: string;
+}): OAuthProvider<{
+    code: string;
+    redirectUri: string;
+}>;

package/dist/server-core/src/auth/discord-oauth.d.ts

@@ -0,0 +1,14 @@
+import type { OAuthProvider } from "./interfaces";
+/**
+ * Creates a Discord OAuth2 Provider integration.
+ *
+ * Uses the authorization code flow. Requires the "identify" and "email"
+ * scopes to retrieve the user's email and profile information.
+ */
+export declare function createDiscordProvider(config: {
+    clientId: string;
+    clientSecret: string;
+}): OAuthProvider<{
+    code: string;
+    redirectUri: string;
+}>;

package/dist/server-core/src/auth/facebook-oauth.d.ts

@@ -0,0 +1,14 @@
+import type { OAuthProvider } from "./interfaces";
+/**
+ * Creates a Facebook / Meta OAuth Provider integration.
+ *
+ * Uses the authorization code flow to exchange a code for an access token,
+ * then fetches user profile from the Facebook Graph API.
+ */
+export declare function createFacebookProvider(config: {
+    clientId: string;
+    clientSecret: string;
+}): OAuthProvider<{
+    code: string;
+    redirectUri: string;
+}>;

package/dist/server-core/src/auth/github-oauth.d.ts

@@ -0,0 +1,15 @@
+import type { OAuthProvider } from "./interfaces";
+/**
+ * Creates a GitHub OAuth Provider integration.
+ *
+ * Flow: Frontend receives an authorization `code` via the GitHub OAuth redirect.
+ * This provider exchanges the code for an access token, then fetches the user's
+ * profile and primary email from the GitHub API.
+ */
+export declare function createGitHubProvider(config: {
+    clientId: string;
+    clientSecret: string;
+}): OAuthProvider<{
+    code: string;
+    redirectUri: string;
+}>;

package/dist/server-core/src/auth/gitlab-oauth.d.ts

@@ -0,0 +1,13 @@
+import type { OAuthProvider } from "./interfaces";
+/**
+ * Creates a GitLab OAuth Provider integration.
+ * Works with both GitLab.com and self-hosted instances.
+ */
+export declare function createGitLabProvider(config: {
+    clientId: string;
+    clientSecret: string;
+    baseUrl?: string;
+}): OAuthProvider<{
+    code: string;
+    redirectUri: string;
+}>;

package/dist/server-core/src/auth/google-oauth.d.ts

@@ -0,0 +1,14 @@
+import type { OAuthProvider } from "./interfaces";
+export interface GoogleUserInfo {
+    googleId: string;
+    email: string;
+    displayName: string | null;
+    photoUrl: string | null;
+    emailVerified: boolean;
+}
+/**
+ * Creates a Google OAuth Provider integration
+ */
+export declare function createGoogleProvider(clientId: string): OAuthProvider<{
+    idToken: string;
+}>;

package/dist/server-core/src/auth/index.d.ts

@@ -0,0 +1,23 @@
+export * from "./interfaces";
+export { configureJwt, generateAccessToken, verifyAccessToken, generateRefreshToken, hashRefreshToken, getRefreshTokenExpiry, getAccessTokenExpiry } from "./jwt";
+export type { JwtConfig, AccessTokenPayload } from "./jwt";
+export { hashPassword, verifyPassword, validatePasswordStrength } from "./password";
+export type { PasswordValidationResult } from "./password";
+export { createGoogleProvider } from "./google-oauth";
+export { createLinkedinProvider } from "./linkedin-oauth";
+export { createGitHubProvider } from "./github-oauth";
+export { createMicrosoftProvider } from "./microsoft-oauth";
+export { createAppleProvider } from "./apple-oauth";
+export { createFacebookProvider } from "./facebook-oauth";
+export { createTwitterProvider } from "./twitter-oauth";
+export { createDiscordProvider } from "./discord-oauth";
+export { createGitLabProvider } from "./gitlab-oauth";
+export { createBitbucketProvider } from "./bitbucket-oauth";
+export { createSlackProvider } from "./slack-oauth";
+export { createSpotifyProvider } from "./spotify-oauth";
+export { requireAuth, requireAdmin, optionalAuth, extractUserFromToken, createAuthMiddleware } from "./middleware";
+export type { AuthMiddlewareOptions, AuthResult } from "./middleware";
+export { createAuthRoutes } from "./routes";
+export type { AuthModuleConfig } from "./routes";
+export { createAdminRoutes } from "./admin-routes";
+export { createRateLimiter, defaultAuthLimiter, strictAuthLimiter } from "./rate-limiter";