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

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

@@ -1,2 +1,16 @@
 import { EntityCollection } from "@rebasepro/types";
-export declare function generateOpenApiSpec(collections: EntityCollection[], basePath?: string): Record<string, unknown>;
+/**
+ * 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/types.d.ts

@@ -74,7 +74,7 @@ export interface QueryOptions {
     where?: Record<string, unknown>;
     orderBy?: Array<{
         field: string;
-        direction: 'asc' | 'desc';
+        direction: "asc" | "desc";
     }>;
     include?: string[];
     /** Columns to return in the response (field-level selection) */

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

@@ -1,7 +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: AuthModuleConfig): Hono<HonoEnv>;
+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

@@ -1,3 +1,4 @@
+import type { OAuthProvider } from "./interfaces";
 export interface GoogleUserInfo {
     googleId: string;
     email: string;
@@ -6,15 +7,8 @@ export interface GoogleUserInfo {
     emailVerified: boolean;
 }
 /**
- * Configure Google OAuth - call this during initialization
+ * Creates a Google OAuth Provider integration
  */
-export declare function configureGoogleOAuth(clientId: string): void;
-/**
- * Verify a Google ID token and extract user information
- * @param idToken The ID token from Google Sign-In on the frontend
- */
-export declare function verifyGoogleIdToken(idToken: string): Promise<GoogleUserInfo | null>;
-/**
- * Check if Google OAuth is configured
- */
-export declare function isGoogleOAuthConfigured(): boolean;
+export declare function createGoogleProvider(clientId: string): OAuthProvider<{
+    idToken: string;
+}>;

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

@@ -1,9 +1,20 @@
+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 { configureGoogleOAuth, verifyGoogleIdToken, isGoogleOAuthConfigured } from "./google-oauth";
-export type { GoogleUserInfo } from "./google-oauth";
+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";

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

@@ -1,3 +1,4 @@
+import { z } from "zod";
 /**
  * Authentication Abstraction Interfaces
  *
@@ -14,8 +15,6 @@ export interface UserData {
     passwordHash?: string | null;
     displayName?: string | null;
     photoUrl?: string | null;
-    provider: string;
-    googleId?: string | null;
     emailVerified: boolean;
     emailVerificationToken?: string | null;
     emailVerificationSentAt?: Date | null;
@@ -30,10 +29,40 @@ export interface CreateUserData {
     passwordHash?: string;
     displayName?: string;
     photoUrl?: string;
-    provider?: string;
-    googleId?: string;
     emailVerified?: boolean;
 }
+/**
+ * User Identity Data (OAuth accounts linked to user)
+ */
+export interface UserIdentityData {
+    id: string;
+    userId: string;
+    provider: string;
+    providerId: string;
+    profileData?: Record<string, unknown> | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Standardized profile data returned by an OAuth provider verification payload
+ */
+export interface OAuthProviderProfile {
+    providerId: string;
+    email: string;
+    displayName?: string | null;
+    photoUrl?: string | null;
+}
+/**
+ * Pluggable OAuth Provider integration strategy
+ */
+export interface OAuthProvider<T = unknown> {
+    /** The identifier of the provider (e.g. "github", "google") */
+    id: string;
+    /** Zod schema validating the expected request payload (e.g. { code: string }) */
+    schema: z.ZodSchema<T>;
+    /** Verify external tokens/codes and return a standardized user profile */
+    verify: (payload: T) => Promise<OAuthProviderProfile | null>;
+}
 /**
  * Role data structure
  */
@@ -99,6 +128,8 @@ export interface ListUsersOptions {
     orderBy?: string;
     /** Sort direction (default "desc") */
     orderDir?: "asc" | "desc";
+    /** Filter by role ID */
+    roleId?: string;
 }
 /**
  * Result of a paginated user listing
@@ -128,9 +159,17 @@ export interface UserRepository {
      */
     getUserByEmail(email: string): Promise<UserData | null>;
     /**
-     * Get a user by Google ID
+     * Get a user by an OAuth identity
+     */
+    getUserByIdentity(provider: string, providerId: string): Promise<UserData | null>;
+    /**
+     * Get all identities linked to a user
+     */
+    getUserIdentities(userId: string): Promise<UserIdentityData[]>;
+    /**
+     * Link a new OAuth identity to a user
      */
-    getUserByGoogleId(googleId: string): Promise<UserData | null>;
+    linkUserIdentity(userId: string, provider: string, providerId: string, profileData?: Record<string, unknown>): Promise<void>;
     /**
      * Update a user
      */

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

@@ -6,6 +6,7 @@ export interface JwtConfig {
 export interface AccessTokenPayload {
     userId: string;
     roles: string[];
+    uid?: string;
 }
 /**
  * Configure JWT settings - call this during initialization.

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

@@ -0,0 +1,18 @@
+import type { OAuthProvider } from "./interfaces";
+export interface LinkedinUserInfo {
+    linkedinId: string;
+    email: string;
+    displayName: string | null;
+    photoUrl: string | null;
+    emailVerified: boolean;
+}
+/**
+ * Creates a LinkedIn OAuth Provider integration
+ */
+export declare function createLinkedinProvider(config: {
+    clientId: string;
+    clientSecret: string;
+}): OAuthProvider<{
+    code: string;
+    redirectUri: string;
+}>;

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

@@ -0,0 +1,16 @@
+import type { OAuthProvider } from "./interfaces";
+/**
+ * Creates a Microsoft / Entra ID (Azure AD) OAuth Provider integration.
+ *
+ * Supports both personal Microsoft accounts and work/school (Azure AD) accounts
+ * via the "common" tenant endpoint. Uses the authorization code flow.
+ */
+export declare function createMicrosoftProvider(config: {
+    clientId: string;
+    clientSecret: string;
+    /** Tenant ID. Defaults to "common" which allows both personal and organizational accounts. */
+    tenantId?: string;
+}): OAuthProvider<{
+    code: string;
+    redirectUri: string;
+}>;

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

@@ -20,16 +20,50 @@ export type AuthResult = boolean | null | undefined | {
 export interface AuthMiddlewareOptions {
     /** DataDriver to scope via withAuth() for RLS */
     driver: DataDriver;
-    /** If true, return 401 when no valid token is present (default: false) */
+    /**
+     * If true, return 401 when no valid token is present.
+     *
+     * **Defaults to `true` (secure by default).** Set to `false` only for
+     * intentionally public endpoints where access control is fully delegated
+     * to Postgres Row-Level Security policies.
+     */
     requireAuth?: boolean;
     /** Optional custom validator (for non-JWT auth, e.g. Firebase Auth) */
     validator?: (c: Context<HonoEnv>) => Promise<AuthResult>;
+    /**
+     * A static secret key for server-to-server / script authentication.
+     *
+     * When a request sends `Authorization: Bearer <key>` and the key matches
+     * this value, the request is granted admin-level access (uid: `service`,
+     * roles: `["admin"]`) **without** JWT verification. The driver is scoped
+     * via `withAuth()` with the service identity.
+     *
+     * This is the Rebase equivalent of a Firebase Service Account key.
+     * Set via `REBASE_SERVICE_KEY` in `.env` and pass through the backend config.
+     *
+     * **Security:** The comparison uses constant-time equality to prevent
+     * timing attacks. The key must be at least 32 characters.
+     */
+    serviceKey?: string;
 }
 /**
- * Express middleware that requires a valid JWT token
+ * Hono middleware that requires a valid JWT token
  * Returns 401 if token is missing or invalid
  */
 export declare const requireAuth: MiddlewareHandler<HonoEnv>;
+/**
+ * Factory that creates a requireAuth middleware with optional service key support.
+ *
+ * When `serviceKey` is provided, the middleware will check if the Bearer token
+ * matches the service key using constant-time comparison. If it matches, the
+ * request is authenticated as a service user with admin privileges.
+ *
+ * This allows admin routes (which use standalone requireAuth + requireAdmin)
+ * to be accessed via service keys for scripts and server-to-server calls.
+ */
+export declare function createRequireAuth(options?: {
+    serviceKey?: string;
+}): MiddlewareHandler<HonoEnv>;
 /**
  * Middleware that requires the user to have an admin or schema-admin role.
  * Must be used AFTER requireAuth or on a route where user is guaranteed.
@@ -44,13 +78,4 @@ export declare const optionalAuth: MiddlewareHandler<HonoEnv>;
  * Extract user from token - for WebSocket authentication
  */
 export declare function extractUserFromToken(token: string): AccessTokenPayload | null;
-/**
- * Create a configurable auth middleware that handles:
- * 1. Token extraction (via custom validator or JWT Bearer token)
- * 2. RLS-scoped DataDriver via withAuth()
- * 3. Optional enforcement (401 when requireAuth is true and no user)
- *
- * This is the single source of truth for HTTP auth in Rebase.
- * Use this instead of manually parsing tokens in route handlers.
- */
 export declare function createAuthMiddleware(options: AuthMiddlewareOptions): MiddlewareHandler<HonoEnv>;

package/dist/server-core/src/auth/rate-limiter.d.ts

@@ -20,12 +20,12 @@ interface RateLimiterOptions {
 export declare function createRateLimiter(options?: RateLimiterOptions): MiddlewareHandler<HonoEnv>;
 /**
  * Pre-configured rate limiter for general auth endpoints (login, register).
- * 20 requests per 15 minutes per IP.
+ * 200 requests per 15 minutes per IP.
  */
 export declare const defaultAuthLimiter: MiddlewareHandler<HonoEnv>;
 /**
  * Pre-configured strict rate limiter for sensitive endpoints (password reset, verification).
- * 5 requests per 15 minutes per IP.
+ * 50 requests per 15 minutes per IP.
  */
 export declare const strictAuthLimiter: MiddlewareHandler<HonoEnv>;
 export {};

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

@@ -1,5 +1,5 @@
 import { Hono } from "hono";
-import type { AuthRepository } from "./interfaces";
+import type { AuthRepository, OAuthProvider } from "./interfaces";
 import { EmailService, EmailConfig } from "../email";
 import { HonoEnv } from "../api/types";
 /**
@@ -9,9 +9,19 @@ export interface AuthModuleConfig {
     authRepo: AuthRepository;
     emailService?: EmailService;
     emailConfig?: EmailConfig;
-    /** Allow new user registration (default: false). First user can always register for bootstrap. */
+    /** Allow new user registration (default: false). */
     allowRegistration?: boolean;
-    /** Default role ID to assign to new users (default: none). The first user always gets "admin". */
+    /** Default role ID to assign to new users (default: none). Must NOT be "admin". */
     defaultRole?: string;
+    /** Optional array of OAuth providers */
+    oauthProviders?: OAuthProvider[];
+    /** When true, blocks all self-registration regardless of `allowRegistration`. */
+    disableSelfRegistration?: boolean;
+    /**
+     * Callback that checks if bootstrap has already been completed.
+     * Used by GET /auth/config to report `needsSetup` status.
+     * When not provided, falls back to checking if any users exist.
+     */
+    isBootstrapCompleted?: () => Promise<boolean>;
 }
 export declare function createAuthRoutes(config: AuthModuleConfig): Hono<HonoEnv>;

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

@@ -0,0 +1,12 @@
+import type { OAuthProvider } from "./interfaces";
+/**
+ * Creates a Slack OAuth Provider integration (OAuth 2.0 / "Sign in with Slack").
+ * Uses the OpenID Connect flow with the "openid,email,profile" scopes.
+ */
+export declare function createSlackProvider(config: {
+    clientId: string;
+    clientSecret: string;
+}): OAuthProvider<{
+    code: string;
+    redirectUri: string;
+}>;

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

@@ -0,0 +1,12 @@
+import type { OAuthProvider } from "./interfaces";
+/**
+ * Creates a Spotify OAuth Provider integration.
+ * Uses the authorization code flow with the "user-read-email" scope.
+ */
+export declare function createSpotifyProvider(config: {
+    clientId: string;
+    clientSecret: string;
+}): OAuthProvider<{
+    code: string;
+    redirectUri: string;
+}>;

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

@@ -0,0 +1,18 @@
+import type { OAuthProvider } from "./interfaces";
+/**
+ * Creates a Twitter/X OAuth 2.0 Provider integration.
+ *
+ * Uses OAuth 2.0 with PKCE (authorization code flow). The frontend must include
+ * the PKCE `code_verifier` when sending the authorization code.
+ *
+ * Twitter API v2 requires the "tweet.read" and "users.read" scopes at minimum,
+ * plus "offline.access" if refresh tokens are needed on Twitter's side.
+ */
+export declare function createTwitterProvider(config: {
+    clientId: string;
+    clientSecret: string;
+}): OAuthProvider<{
+    code: string;
+    redirectUri: string;
+    codeVerifier: string;
+}>;

package/dist/server-core/src/cron/cron-loader.d.ts

@@ -0,0 +1,17 @@
+import type { CronJobDefinition } from "@rebasepro/types";
+export interface LoadedCronJob {
+    /** Job ID derived from filename (e.g. "cleanup-sessions"). */
+    id: string;
+    /** The full definition. */
+    definition: CronJobDefinition;
+}
+/**
+ * Auto-discover cron job files from a directory.
+ *
+ * Each file should default-export a `CronJobDefinition`.
+ * The filename (without extension) becomes the job ID:
+ *   `crons/cleanup-sessions.ts` → id = "cleanup-sessions"
+ *
+ * Follows the same discovery pattern as `loadFunctionsFromDirectory`.
+ */
+export declare function loadCronJobsFromDirectory(directory: string): Promise<LoadedCronJob[]>;

package/dist/server-core/src/cron/cron-routes.d.ts

@@ -0,0 +1,14 @@
+import { Hono } from "hono";
+import type { HonoEnv } from "../api/types";
+import type { CronScheduler } from "./cron-scheduler";
+/**
+ * Create admin REST routes for managing cron jobs.
+ *
+ * Routes:
+ *   GET    /          → list all cron jobs
+ *   GET    /:id       → get a single job's status
+ *   POST   /:id/trigger → manually trigger a job
+ *   GET    /:id/logs  → get execution logs for a job
+ *   PUT    /:id       → update job (enable/disable)
+ */
+export declare function createCronRoutes(scheduler: CronScheduler): Hono<HonoEnv>;

package/dist/server-core/src/cron/cron-scheduler.d.ts

@@ -0,0 +1,61 @@
+import type { CronJobStatus, CronJobLogEntry } from "@rebasepro/types";
+import type { RebaseClient } from "@rebasepro/client";
+import type { LoadedCronJob } from "./cron-loader";
+import type { CronStore } from "./cron-store";
+export declare class CronScheduler {
+    private jobs;
+    private started;
+    private store?;
+    private client?;
+    /**
+     * Set the RebaseClient instance to make it available to cron job handlers.
+     */
+    setClient(client: RebaseClient): void;
+    /**
+     * Attach a persistence store for cron logs.
+     * When set, execution logs are written to the database after each run,
+     * and counters are seeded from the database on start.
+     */
+    setStore(store: CronStore): void;
+    /**
+     * Register a batch of loaded cron jobs.
+     */
+    registerJobs(loadedJobs: LoadedCronJob[]): void;
+    /**
+     * Start the scheduler — begins ticking all enabled jobs.
+     */
+    start(): void;
+    /**
+     * Stop the scheduler and clear all timers.
+     */
+    stop(): void;
+    /**
+     * List all registered jobs with their current status.
+     */
+    listJobs(): CronJobStatus[];
+    /**
+     * Get a single job status by ID.
+     */
+    getJob(id: string): CronJobStatus | undefined;
+    /**
+     * Get log entries for a job.
+     */
+    getJobLogs(id: string, limit?: number): CronJobLogEntry[];
+    /**
+     * Get log entries for a job from the database (if store is available).
+     * Falls back to in-memory logs if no store is configured.
+     */
+    getJobLogsFromDb(id: string, limit?: number): Promise<CronJobLogEntry[]>;
+    /**
+     * Enable or disable a job at runtime.
+     */
+    setJobEnabled(id: string, enabled: boolean): CronJobStatus | undefined;
+    /**
+     * Manually trigger a job execution immediately.
+     */
+    triggerJob(id: string): Promise<CronJobLogEntry | undefined>;
+    private scheduleNext;
+    private stopJob;
+    private executeJob;
+    private toStatus;
+}

package/dist/server-core/src/cron/cron-store.d.ts

@@ -0,0 +1,32 @@
+import type { CronJobLogEntry } from "@rebasepro/types";
+import type { DataDriver } 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;
+    }>>;
+}
+export declare function createCronStore(driver: DataDriver): CronStore | undefined;

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

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

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

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

package/dist/server-core/src/email/templates.d.ts

@@ -30,4 +30,13 @@ export declare function getUserInvitationTemplate(setPasswordUrl: string, user:
     html: string;
     text: string;
 };
+/**
+ * Default welcome email template
+ * Sent automatically when a new user registers
+ */
+export declare function getWelcomeEmailTemplate(user: TemplateUser, appName?: string, loginUrl?: string): {
+    subject: string;
+    html: string;
+    text: string;
+};
 export {};