@rebasepro/server-core 0.0.1-canary.000dc36

package/src/cron/cron-store.ts

@@ -0,0 +1,163 @@
+import type { CronJobLogEntry } from "@rebasepro/types";
+import type { DataDriver } from "@rebasepro/types";
+import { isSQLAdmin } from "@rebasepro/types";
+
+/**
+ * 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)) {
+        console.warn("⚠️ [cron-store] DataDriver does not support SQL admin — cron logs will not be persisted.");
+        return undefined;
+    }
+
+    const exec = admin.executeSql.bind(admin);
+
+    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)
+                `);
+
+                console.log("✅ Cron logs table ready");
+            } catch (err) {
+                console.error("❌ Failed to create cron logs table:", err);
+                console.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;
+                const errorEscaped = entry.error ? entry.error.replace(/'/g, "''") : null;
+
+                await exec(`
+                    INSERT INTO ${TABLE} (job_id, started_at, finished_at, duration_ms, success, error, result, logs, manual)
+                    VALUES (
+                        '${entry.jobId}',
+                        '${entry.startedAt}',
+                        '${entry.finishedAt}',
+                        ${entry.durationMs},
+                        ${entry.success},
+                        ${errorEscaped ? `'${errorEscaped}'` : "NULL"},
+                        ${resultJson ? `'${resultJson.replace(/'/g, "''")}'::jsonb` : "NULL"},
+                        ${logsJson ? `'${logsJson.replace(/'/g, "''")}'::jsonb` : "NULL"},
+                        ${entry.manual}
+                    )
+                `);
+            } catch (err) {
+                // Non-blocking — log persistence should never crash the scheduler
+                console.error(`[cron-store] Failed to persist log for "${entry.jobId}":`, 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 = '${jobId}'
+                    ORDER BY started_at DESC
+                    LIMIT ${limit}
+                `);
+
+                return rows.map(rowToLogEntry);
+            } catch (err) {
+                console.error(`[cron-store] Failed to fetch logs for "${jobId}":`, 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) {
+                console.error("[cron-store] Failed to fetch job stats:", 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 ? JSON.parse(row.logs as string) : []),
+        manual: row.manual as boolean
+    };
+}

package/src/cron/index.ts

@@ -0,0 +1,6 @@
+export { loadCronJobsFromDirectory } from "./cron-loader";
+export type { LoadedCronJob } from "./cron-loader";
+export { CronScheduler, validateCronExpression } from "./cron-scheduler";
+export { createCronRoutes } from "./cron-routes";
+export { createCronStore } from "./cron-store";
+export type { CronStore } from "./cron-store";

package/src/db/interfaces.ts

@@ -0,0 +1,60 @@
+/**
+ * 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

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

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

@@ -0,0 +1,91 @@
+import { createTransport, Transporter } from "nodemailer";
+import { EmailService, EmailSendOptions, EmailConfig } from "./types";
+
+/**
+ * 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) {
+            this.transporter = createTransport({
+                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);
+            console.error("Failed to send email:", 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);
+            console.error("SMTP connection verification failed:", message);
+            return false;
+        }
+    }
+}
+
+/**
+ * Create an email service from configuration
+ */
+export function createEmailService(config: EmailConfig): EmailService {
+    return new SMTPEmailService(config);
+}