@rebasepro/server-core 0.7.0 → 0.9.0

package/src/cron/cron-store.ts

@@ -1,166 +0,0 @@
-import type { CronJobLogEntry } from "@rebasepro/types";
-import type { DataDriver } from "@rebasepro/types";
-import { isSQLAdmin } from "@rebasepro/types";
-import { logger } from "../utils/logger.js";
-
-/**
- * Persistence layer for cron job execution logs.
- *
- * Uses the DataDriver's `admin.executeSql` capability to store logs in a
- * `rebase.cron_logs` table. Falls back gracefully if the driver doesn't
- * support SQL (e.g. MongoDB) — in that case, no persistence occurs.
- */
-export interface CronStore {
-    /** Ensure the backing table exists. Called once on startup. */
-    ensureTable(): Promise<void>;
-
-    /** Persist a single log entry after execution. */
-    insertLog(entry: CronJobLogEntry): Promise<void>;
-
-    /**
-     * Fetch the most recent logs for a job.
-     * @param jobId  The job identifier
-     * @param limit  Max entries to return (default 50)
-     * @returns Logs sorted newest-first
-     */
-    fetchLogs(jobId: string, limit?: number): Promise<CronJobLogEntry[]>;
-
-    /**
-     * Fetch aggregate stats for all jobs (totalRuns, totalFailures, lastRunAt).
-     * Used to seed in-memory counters on startup.
-     */
-    fetchJobStats(): Promise<Map<string, { totalRuns: number; totalFailures: number; lastRunAt?: string }>>;
-}
-
-// ─── SQL-based implementation ────────────────────────────────────────
-
-const TABLE = "rebase.cron_logs";
-
-export function createCronStore(driver: DataDriver): CronStore | undefined {
-    const admin = driver.admin;
-    if (!isSQLAdmin(admin)) {
-        logger.warn("⚠️ [cron-store] DataDriver does not support SQL admin — cron logs will not be persisted.");
-        return undefined;
-    }
-
-    const exec = (sqlText: string, options?: { params?: unknown[] }) =>
-        admin.executeSql(sqlText, options?.params ? { params: options.params } : undefined);
-
-    return {
-        async ensureTable(): Promise<void> {
-            try {
-                await exec("CREATE SCHEMA IF NOT EXISTS rebase");
-                await exec(`
-                    CREATE TABLE IF NOT EXISTS ${TABLE} (
-                        id TEXT PRIMARY KEY DEFAULT gen_random_uuid()::text,
-                        job_id TEXT NOT NULL,
-                        started_at TIMESTAMPTZ NOT NULL,
-                        finished_at TIMESTAMPTZ NOT NULL,
-                        duration_ms INTEGER NOT NULL,
-                        success BOOLEAN NOT NULL DEFAULT true,
-                        error TEXT,
-                        result JSONB,
-                        logs JSONB,
-                        manual BOOLEAN NOT NULL DEFAULT false
-                    )
-                `);
-
-                await exec(`
-                    CREATE INDEX IF NOT EXISTS idx_cron_logs_job
-                    ON ${TABLE}(job_id, started_at DESC)
-                `);
-
-                logger.info("✅ Cron logs table ready");
-            } catch (err) {
-                logger.error("❌ Failed to create cron logs table", { error: err });
-                logger.warn("⚠️ Continuing without cron log persistence.");
-            }
-        },
-
-        async insertLog(entry: CronJobLogEntry): Promise<void> {
-            try {
-                const resultJson = entry.result !== undefined ? JSON.stringify(entry.result) : null;
-                const logsJson = entry.logs.length > 0 ? JSON.stringify(entry.logs) : null;
-
-                await exec(
-                    `INSERT INTO ${TABLE} (job_id, started_at, finished_at, duration_ms, success, error, result, logs, manual)
-                     VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb, $8::jsonb, $9)`,
-                    { params: [
-                        entry.jobId,
-                        entry.startedAt,
-                        entry.finishedAt,
-                        entry.durationMs,
-                        entry.success,
-                        entry.error || null,
-                        resultJson,
-                        logsJson,
-                        entry.manual
-                    ]}
-                );
-            } catch (err) {
-                // Non-blocking — log persistence should never crash the scheduler
-                logger.error(`[cron-store] Failed to persist log for "${entry.jobId}"`, { error: err });
-            }
-        },
-
-        async fetchLogs(jobId: string, limit = 50): Promise<CronJobLogEntry[]> {
-            try {
-                const rows = await exec(
-                    `SELECT job_id, started_at, finished_at, duration_ms, success, error, result, logs, manual
-                     FROM ${TABLE}
-                     WHERE job_id = $1
-                     ORDER BY started_at DESC
-                     LIMIT $2`,
-                    { params: [jobId, limit] }
-                );
-
-                return rows.map(rowToLogEntry);
-            } catch (err) {
-                logger.error(`[cron-store] Failed to fetch logs for "${jobId}"`, { error: err });
-                return [];
-            }
-        },
-
-        async fetchJobStats(): Promise<Map<string, { totalRuns: number; totalFailures: number; lastRunAt?: string }>> {
-            const stats = new Map<string, { totalRuns: number; totalFailures: number; lastRunAt?: string }>();
-            try {
-                const rows = await exec(`
-                    SELECT
-                        job_id,
-                        COUNT(*)::int AS total_runs,
-                        COUNT(*) FILTER (WHERE NOT success)::int AS total_failures,
-                        MAX(started_at) AS last_run_at
-                    FROM ${TABLE}
-                    GROUP BY job_id
-                `);
-
-                for (const row of rows) {
-                    stats.set(row.job_id as string, {
-                        totalRuns: row.total_runs as number,
-                        totalFailures: row.total_failures as number,
-                        lastRunAt: row.last_run_at ? new Date(row.last_run_at as string).toISOString() : undefined
-                    });
-                }
-            } catch (err) {
-                logger.error("[cron-store] Failed to fetch job stats", { error: err });
-            }
-            return stats;
-        }
-    };
-}
-
-// ─── Helpers ─────────────────────────────────────────────────────────
-
-function rowToLogEntry(row: Record<string, unknown>): CronJobLogEntry {
-    return {
-        jobId: row.job_id as string,
-        startedAt: new Date(row.started_at as string).toISOString(),
-        finishedAt: new Date(row.finished_at as string).toISOString(),
-        durationMs: row.duration_ms as number,
-        success: row.success as boolean,
-        error: (row.error as string) ?? undefined,
-        result: row.result ?? undefined,
-        logs: Array.isArray(row.logs) ? row.logs : (row.logs ? (() => { try { return JSON.parse(row.logs as string); } catch { return []; } })() : []),
-        manual: row.manual as boolean
-    };
-}

package/src/db/interfaces.ts

@@ -1,60 +0,0 @@
-/**
- * Database Abstraction Interfaces
- *
- * These interfaces define the contracts that any database backend must implement
- * to be used with Rebase. This allows for pluggable database backends like
- * PostgreSQL, MongoDB, MySQL, etc.
- */
-
-import {
-    Entity,
-    EntityCollection,
-    FilterValues,
-    WhereFilterOp,
-    DatabaseConnection,
-    QueryFilter,
-    FetchCollectionOptions,
-    SearchOptions,
-    CountOptions,
-    ConditionBuilder,
-    ConditionBuilderStatic,
-    EntityRepository,
-    CollectionSubscriptionConfig,
-    EntitySubscriptionConfig,
-    RealtimeProvider,
-    CollectionRegistryInterface,
-    DataTransformer,
-    BackendConfig,
-    BackendInstance,
-    BackendFactory
-} from "@rebasepro/types";
-import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { PgTransaction } from "drizzle-orm/pg-core";
-
-/**
- * Type representing either a direct database connection or a transaction.
- * Used to allow services to operate within a transaction context.
- * Note: `any` is intentional here — it represents a Drizzle client with
- * a dynamic schema, enabling `db.query[tableName]` access without casts.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type DrizzleClient = NodePgDatabase<Record<string, unknown>> | PgTransaction<any, any, any>;
-
-export type {
-    DatabaseConnection,
-    QueryFilter,
-    FetchCollectionOptions,
-    SearchOptions,
-    CountOptions,
-    ConditionBuilder,
-    ConditionBuilderStatic,
-    EntityRepository,
-    CollectionSubscriptionConfig,
-    EntitySubscriptionConfig,
-    RealtimeProvider,
-    CollectionRegistryInterface,
-    DataTransformer,
-    BackendConfig,
-    BackendInstance,
-    BackendFactory
-};

package/src/email/index.ts

@@ -1,19 +0,0 @@
-/**
- * Email module exports
- */
-
-export type {
-    EmailService,
-    EmailSendOptions,
-    SMTPConfig,
-    EmailConfig,
-    PasswordResetTemplateFunction,
-    EmailVerificationTemplateFunction,
-    UserInvitationTemplateFunction,
-    WelcomeEmailTemplateFunction,
-    MagicLinkTemplateFunction
-} from "./types";
-
-export { SMTPEmailService, createEmailService } from "./smtp-email-service";
-
-export { getPasswordResetTemplate, getEmailVerificationTemplate, getUserInvitationTemplate, getWelcomeEmailTemplate, getMagicLinkTemplate } from "./templates";

package/src/email/smtp-email-service.ts

@@ -1,123 +0,0 @@
-import { createTransport, Transporter } from "nodemailer";
-import { EmailService, EmailSendOptions, EmailConfig } from "./types";
-import { logger } from "../utils/logger";
-
-/**
- * Safely parse a hostname from a URL string
- */
-function getHostname(urlStr: string): string | undefined {
-    try {
-        const url = new URL(urlStr.includes("://") ? urlStr : `https://${urlStr}`);
-        return url.hostname;
-    } catch {
-        return undefined;
-    }
-}
-
-/**
- * SMTP Email Service implementation using Nodemailer
- */
-export class SMTPEmailService implements EmailService {
-    private transporter: Transporter | null = null;
-    private config: EmailConfig;
-
-    constructor(config: EmailConfig) {
-        this.config = config;
-
-        if (config.smtp) {
-            let smtpName = config.smtp.name;
-            if (!smtpName) {
-                const urlsToTry = [
-                    process.env.FRONTEND_URL,
-                    config.resetPasswordUrl,
-                    config.verifyEmailUrl
-                ];
-                for (const urlStr of urlsToTry) {
-                    if (urlStr) {
-                        const hostname = getHostname(urlStr);
-                        if (hostname) {
-                            smtpName = hostname;
-                            break;
-                        }
-                    }
-                }
-            }
-
-            this.transporter = createTransport({
-                name: smtpName,
-                host: config.smtp.host,
-                port: config.smtp.port,
-                secure: config.smtp.secure ?? (config.smtp.port === 465),
-                auth: config.smtp.auth ? {
-                    user: config.smtp.auth.user,
-                    pass: config.smtp.auth.pass
-                } : undefined
-            });
-        }
-    }
-
-    /**
-     * Check if the email service is properly configured
-     */
-    isConfigured(): boolean {
-        return !!(this.transporter || this.config.sendEmail);
-    }
-
-    /**
-     * Send an email using SMTP or custom send function
-     */
-    async send(options: EmailSendOptions): Promise<void> {
-        // Use custom send function if provided
-        if (this.config.sendEmail) {
-            await this.config.sendEmail(options);
-            return;
-        }
-
-        // Use SMTP transporter
-        if (!this.transporter) {
-            throw new Error("Email service not configured. Provide SMTP config or sendEmail function.");
-        }
-
-        const to = Array.isArray(options.to) ? options.to.join(", ") : options.to;
-
-        try {
-            await this.transporter.sendMail({
-                from: this.config.from,
-                to,
-                subject: options.subject,
-                html: options.html,
-                text: options.text,
-                replyTo: options.replyTo
-            });
-        } catch (error: unknown) {
-            const message = error instanceof Error ? error.message : String(error);
-            logger.error("Failed to send email", { detail: message });
-            throw new Error(`Failed to send email: ${message}`);
-        }
-    }
-
-    /**
-     * Verify SMTP connection (useful for startup checks)
-     */
-    async verifyConnection(): Promise<boolean> {
-        if (!this.transporter) {
-            return !!this.config.sendEmail;
-        }
-
-        try {
-            await this.transporter.verify();
-            return true;
-        } catch (error: unknown) {
-            const message = error instanceof Error ? error.message : String(error);
-            logger.error("SMTP connection verification failed", { detail: message });
-            return false;
-        }
-    }
-}
-
-/**
- * Create an email service from configuration
- */
-export function createEmailService(config: EmailConfig): EmailService {
-    return new SMTPEmailService(config);
-}