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

package/src/storage/storage-registry.ts

@@ -0,0 +1,187 @@
+/**
+ * Storage Registry
+ *
+ * Manages multiple storage controllers for Rebase backend.
+ * Allows different storage backends for different use cases.
+ *
+ * Usage:
+ * - Single storage: Pass a single StorageController → maps to "(default)"
+ * - Multiple storages: Pass a map of { storageId: StorageController }
+ * - String properties use `storageId` in their config to specify which storage to use
+ * - Properties without `storageId` fallback to "(default)"
+ */
+
+import { StorageController } from "./types";
+
+/**
+ * The default storage identifier used when:
+ * - A single storage controller is provided (not a map)
+ * - A property doesn't specify a storageId
+ */
+export const DEFAULT_STORAGE_ID = "(default)";
+
+/**
+ * Registry for managing multiple storage controllers
+ */
+export interface StorageRegistry {
+    /**
+     * Register a storage controller with an ID
+     * @param id - Unique identifier for this storage (e.g., "media", "backups")
+     * @param controller - The StorageController instance
+     */
+    register(id: string, controller: StorageController): void;
+
+    /**
+     * Get the default storage controller (id = "(default)")
+     * @throws Error if no default storage is registered
+     */
+    getDefault(): StorageController;
+
+    /**
+     * Get a storage controller by ID
+     * @param id - Storage identifier, or undefined/null for default
+     * @returns The StorageController, or undefined if not found
+     */
+    get(id: string | undefined | null): StorageController | undefined;
+
+    /**
+     * Get a storage controller by ID, with fallback to default
+     * @param id - Storage identifier, or undefined/null for default
+     * @returns The StorageController (falls back to default if id not found)
+     * @throws Error if neither the specified nor default storage exists
+     */
+    getOrDefault(id: string | undefined | null): StorageController;
+
+    /**
+     * Check if a storage with the given ID exists
+     */
+    has(id: string): boolean;
+
+    /**
+     * List all registered storage IDs
+     */
+    list(): string[];
+
+    /**
+     * Get the number of registered storage controllers
+     */
+    size(): number;
+}
+
+/**
+ * Default implementation of StorageRegistry
+ */
+export class DefaultStorageRegistry implements StorageRegistry {
+    private controllers = new Map<string, StorageController>();
+
+    /**
+     * Create a StorageRegistry from either a single controller or a map
+     * @param input - Single StorageController (maps to "(default)") or Record<string, StorageController>
+     */
+    static create(
+        input: StorageController | Record<string, StorageController>
+    ): DefaultStorageRegistry {
+        const registry = new DefaultStorageRegistry();
+
+        if (isStorageController(input)) {
+            // Single controller → register as "(default)"
+            registry.register(DEFAULT_STORAGE_ID, input);
+        } else {
+            // Map of controllers → register each
+            for (const [id, controller] of Object.entries(input)) {
+                if (isStorageController(controller)) {
+                    registry.register(id, controller);
+                }
+            }
+            // Ensure there's a default if not explicitly provided
+            if (!registry.has(DEFAULT_STORAGE_ID) && registry.size() > 0) {
+                // If no explicit "(default)", use the first one as default
+                const firstId = Object.keys(input).find(k => isStorageController(input[k]));
+                if (firstId) {
+                    console.warn(
+                        `[StorageRegistry] No "${DEFAULT_STORAGE_ID}" storage provided. ` +
+                        `Using "${firstId}" as the default.`
+                    );
+                    registry.register(DEFAULT_STORAGE_ID, input[firstId]);
+                }
+            }
+        }
+
+        return registry;
+    }
+
+    register(id: string, controller: StorageController): void {
+        if (this.controllers.has(id)) {
+            console.warn(`[StorageRegistry] Overwriting storage with id "${id}"`);
+        }
+        this.controllers.set(id, controller);
+    }
+
+    getDefault(): StorageController {
+        const controller = this.controllers.get(DEFAULT_STORAGE_ID);
+        if (!controller) {
+            throw new Error(
+                `[StorageRegistry] No default storage registered. ` +
+                `Register one with id "${DEFAULT_STORAGE_ID}" or pass a single StorageController.`
+            );
+        }
+        return controller;
+    }
+
+    get(id: string | undefined | null): StorageController | undefined {
+        if (id === undefined || id === null) {
+            return this.controllers.get(DEFAULT_STORAGE_ID);
+        }
+        return this.controllers.get(id);
+    }
+
+    getOrDefault(id: string | undefined | null): StorageController {
+        // If no ID specified, return default
+        if (id === undefined || id === null) {
+            return this.getDefault();
+        }
+
+        // Try to get by ID
+        const controller = this.controllers.get(id);
+        if (controller) {
+            return controller;
+        }
+
+        // Fallback to default with warning
+        console.warn(
+            `[StorageRegistry] Storage "${id}" not found, falling back to "${DEFAULT_STORAGE_ID}"`
+        );
+        return this.getDefault();
+    }
+
+    has(id: string): boolean {
+        return this.controllers.has(id);
+    }
+
+    list(): string[] {
+        return Array.from(this.controllers.keys());
+    }
+
+    size(): number {
+        return this.controllers.size;
+    }
+}
+
+/**
+ * Type guard to check if an object is a StorageController
+ * vs a Record<string, StorageController> (multiple storages)
+ */
+function isStorageController(obj: unknown): obj is StorageController {
+    if (typeof obj !== "object" || obj === null) {
+        return false;
+    }
+    const controller = obj as StorageController;
+    // Check for required StorageController properties
+    return (
+        typeof controller.uploadFile === "function" &&
+        typeof controller.getDownloadURL === "function" &&
+        typeof controller.deleteFile === "function" &&
+        typeof controller.list === "function" &&
+        typeof controller.getType === "function"
+    );
+}

package/src/storage/types.ts

@@ -0,0 +1,122 @@
+/**
+ * Storage configuration and types for Rebase backend
+ */
+
+import { StorageSource, UploadFileProps, UploadFileResult, DownloadConfig, StorageListResult, StorageReference } from "@rebasepro/types";
+
+/**
+ * Local filesystem storage configuration
+ */
+export interface LocalStorageConfig {
+    type: 'local';
+    /** Base directory for file storage (e.g., './uploads') */
+    basePath: string;
+    /** Maximum file size in bytes (default: 50MB) */
+    maxFileSize?: number;
+    /** Allowed MIME types (if not set, all types allowed) */
+    allowedMimeTypes?: string[];
+    /** Base URL for generating download URLs (default: auto-detected from request) */
+    baseUrl?: string;
+}
+
+/**
+ * S3-compatible storage configuration (works with AWS S3 and MinIO)
+ */
+export interface S3StorageConfig {
+    type: 's3';
+    /** S3 bucket name */
+    bucket: string;
+    /** AWS region (e.g., 'us-east-1') */
+    region?: string;
+    /** Custom endpoint URL (required for MinIO) */
+    endpoint?: string;
+    /** AWS access key ID */
+    accessKeyId: string;
+    /** AWS secret access key */
+    secretAccessKey: string;
+    /** Use path-style URLs (required for MinIO) */
+    forcePathStyle?: boolean;
+    /** Maximum file size in bytes (default: 50MB) */
+    maxFileSize?: number;
+    /** Allowed MIME types (if not set, all types allowed) */
+    allowedMimeTypes?: string[];
+    /** URL expiration time in seconds for signed URLs (default: 3600) */
+    signedUrlExpiration?: number;
+}
+
+/**
+ * Storage configuration - either local filesystem or S3-compatible
+ */
+export type BackendStorageConfig = LocalStorageConfig | S3StorageConfig;
+
+/**
+ * Storage controller interface for backend implementations
+ */
+export interface StorageController {
+    /**
+     * Upload a file
+     */
+    uploadFile(props: UploadFileProps): Promise<UploadFileResult>;
+
+    /**
+     * Get a download URL for a file
+     */
+    getDownloadURL(path: string, bucket?: string): Promise<DownloadConfig>;
+
+    /**
+     * Get file as a File object
+     */
+    getFile(path: string, bucket?: string): Promise<File | null>;
+
+    /**
+     * Delete a file
+     */
+    deleteFile(path: string, bucket?: string): Promise<void>;
+
+    /**
+     * List files in a path
+     */
+    list(path: string, options?: {
+        bucket?: string;
+        maxResults?: number;
+        pageToken?: string;
+    }): Promise<StorageListResult>;
+
+    /**
+     * Get the storage configuration type
+     */
+    getType(): 'local' | 's3';
+}
+
+/**
+ * Default maximum file size (50MB)
+ */
+export const DEFAULT_MAX_FILE_SIZE = 50 * 1024 * 1024;
+
+/**
+ * Common image MIME types
+ */
+export const IMAGE_MIME_TYPES = [
+    'image/jpeg',
+    'image/png',
+    'image/gif',
+    'image/webp',
+    'image/svg+xml',
+    'image/bmp',
+    'image/tiff'
+];
+
+/**
+ * Common document MIME types
+ */
+export const DOCUMENT_MIME_TYPES = [
+    'application/pdf',
+    'application/msword',
+    'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    'application/vnd.ms-excel',
+    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    'application/vnd.ms-powerpoint',
+    'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    'text/plain',
+    'text/csv'
+];

package/src/types/index.ts

@@ -0,0 +1,27 @@
+import { 
+  Entity, 
+  EntityCollection, 
+  EntityStatus, 
+  FilterValues,
+  FetchCollectionProps,
+  FetchEntityProps,
+  SaveEntityProps,
+  DeleteEntityProps,
+  WebSocketMessage,
+  CollectionUpdateMessage,
+  EntityUpdateMessage
+} from "@rebasepro/types";
+
+// Subscription types
+export interface ListenCollectionRequest<M extends Record<string, unknown> = Record<string, unknown>> extends FetchCollectionProps<M> {
+  subscriptionId: string;
+  onUpdate: (entities: Entity<M>[]) => void;
+  onError?: (error: Error) => void;
+}
+
+export interface ListenEntityRequest<M extends Record<string, unknown> = Record<string, unknown>> extends FetchEntityProps<M> {
+  subscriptionId: string;
+  onUpdate: (entity: Entity<M> | null) => void;
+  onError?: (error: Error) => void;
+}
+

package/src/utils/logging.ts

@@ -0,0 +1,35 @@
+/**
+ * Configure console log levels based on environment variable
+ * Call this early in your application to set up proper logging levels
+ */
+export function configureLogLevel(logLevel?: string) {
+    const LOG_LEVEL = logLevel || process.env.LOG_LEVEL || 'info';
+    const logLevels = { error: 0, warn: 1, info: 2, debug: 3 };
+    const currentLevel = logLevels[LOG_LEVEL as keyof typeof logLevels] ?? 2;
+
+    if (currentLevel < 3) console.debug = () => { };
+    if (currentLevel < 2) console.log = () => { };
+    if (currentLevel < 1) console.warn = () => { };
+    if (currentLevel < 0) console.error = () => { };
+}
+
+/**
+ * Reset console methods to their original state
+ */
+export function resetConsole() {
+    // Store original methods if not already stored
+    if (!(global as unknown as Record<string, unknown>).__originalConsole) {
+        (global as unknown as Record<string, unknown>).__originalConsole = {
+            log: console.log,
+            warn: console.warn,
+            error: console.error,
+            debug: console.debug
+        };
+    }
+
+    const original = (global as unknown as Record<string, unknown>).__originalConsole as Console;
+    console.log = original.log;
+    console.warn = original.warn;
+    console.error = original.error;
+    console.debug = original.debug;
+}

package/src/utils/sql.ts

@@ -0,0 +1,38 @@
+import { sql, SQL } from "drizzle-orm";
+
+/**
+ * Returns a SQL chunk calling `auth.uid()` — the current user's ID.
+ * This is a Supabase-style helper function created in the `auth` schema
+ * that reads `app.user_id` set per-transaction by `withAuth()`.
+ *
+ * @example
+ * sql`${table.user_id} = ${authUid()}`
+ */
+export const authUid = (): SQL => {
+    return sql`auth.uid()`;
+};
+
+/**
+ * Returns a SQL chunk calling `auth.roles()` — the current user's roles
+ * as a comma-separated string.
+ * Reads `app.user_roles` set per-transaction by `withAuth()`.
+ *
+ * @example
+ * sql`auth.roles() ~ 'admin'`
+ */
+export const authRoles = (): SQL => {
+    return sql`auth.roles()`;
+};
+
+/**
+ * Returns a SQL chunk calling `auth.jwt()` — the full JWT claims as JSONB.
+ * Reads `app.jwt` set per-transaction by `withAuth()`.
+ *
+ * @example
+ * sql`auth.jwt()->>'sub'`
+ */
+export const authJwt = (): SQL => {
+    return sql`auth.jwt()`;
+};
+
+