@ubean/server 0.1.12 → 0.2.0

package/dist/cache-directive-CAxJAQyE.d.ts

@@ -0,0 +1,175 @@
+//#region src/cache-directive.d.ts
+/**
+ * 组件级缓存 —— 运行时原语
+ *
+ * 通过 `defineCachedFunction()` 显式包装异步函数,缓存其返回值。
+ *
+ * 设计要点:
+ * - **值缓存**(非 HTTP 响应缓存):缓存异步函数的返回值(JSON 可序列化),
+ *   与 `cache.ts`(HTTP 响应缓存)解耦。
+ * - **AsyncLocalStorage 作用域**:`cacheLife()` / `cacheTag()` 通过 ALS 写入
+ *   当前缓存的执行作用域,无需手动传递 scope 对象。
+ * - **标签失效**:`revalidateTag(tag)` 失效所有带该标签的缓存条目;
+ *   `revalidatePath(path)` 失效匹配路径的缓存条目。
+ * - **零外部依赖**:使用内置 `AsyncLocalStorage` + `Map` 内存存储。
+ *
+ * 用户通过 `defineCachedFunction(fn, options)` 显式声明缓存函数,无需 Vite 插件
+ * 参与,运行时通过此模块的 API 执行缓存逻辑。
+ */
+/**
+ * 组件级缓存条目。存储序列化后的值 + 标签 + 过期时间。
+ */
+interface ComponentCacheEntry {
+  /** JSON 序列化后的返回值。 */
+  value: string;
+  /** 关联的标签列表(用于 `revalidateTag`)。 */
+  tags: string[];
+  /** 创建时间戳(ms)。 */
+  createdAt: number;
+  /** 过期时间戳(ms)。 */
+  expiresAt: number;
+}
+/**
+ * 组件级缓存存储接口。
+ *
+ * 与 `CacheStore`(HTTP 响应缓存)不同,此接口存储任意 JSON 可序列化值。
+ */
+interface ComponentCacheStore {
+  get(key: string): Promise<ComponentCacheEntry | undefined>;
+  set(key: string, entry: Omit<ComponentCacheEntry, 'createdAt' | 'expiresAt'>, ttl: number): Promise<void>;
+  delete(key: string): Promise<boolean>;
+  clear(): Promise<void>;
+  /** 返回所有键(用于标签/路径失效扫描)。 */
+  keys?: () => Promise<string[]>;
+}
+/**
+ * 默认内存组件缓存存储。带标签反向索引以加速 `revalidateTag`。
+ */
+declare function createComponentMemoryStore(maxEntries?: number): ComponentCacheStore;
+declare function useComponentCacheStore(store?: ComponentCacheStore): ComponentCacheStore;
+declare function clearComponentCacheStore(): void;
+/**
+ * 设置当前缓存作用域的 TTL(秒)。
+ *
+ * 必须在 `defineCachedFunction()` 包装的函数体内调用,否则为空操作(允许在
+ * 非缓存上下文中调用以简化条件逻辑)。
+ *
+ * @example
+ * ```ts
+ * const getUser = defineCachedFunction(
+ *   async (id: string) => {
+ *     cacheLife(3600); // 缓存 1 小时
+ *     return await db.query.user.findById(id);
+ *   },
+ *   { name: 'getUser' }
+ * );
+ * ```
+ */
+declare function cacheLife(seconds: number): void;
+/**
+ * 为当前缓存作用域添加标签。
+ *
+ * 标签可用于通过 `revalidateTag(tag)` 精确失效缓存。
+ *
+ * @example
+ * ```ts
+ * const getUser = defineCachedFunction(
+ *   async (id: string) => {
+ *     cacheTag('users', `user:${id}`);
+ *     return await db.query.user.findById(id);
+ *   },
+ *   { name: 'getUser' }
+ * );
+ *
+ * // 失效所有带 'users' 标签的缓存
+ * await revalidateTag('users');
+ * ```
+ */
+declare function cacheTag(...tags: string[]): void;
+/**
+ * 缓存函数选项。
+ */
+interface CachedFunctionOptions {
+  /** 缓存键前缀(通常是函数名或文件路径 + 函数名)。 */
+  name: string;
+  /** 默认 TTL(秒)。未调用 `cacheLife()` 时使用。默认 60。 */
+  defaultTtl?: number;
+  /**
+   * 自定义缓存键生成函数。默认使用 `name + JSON.stringify(args)`。
+   * 用于精细化控制缓存键(例如排除不稳定的参数)。
+   */
+  getKey?: (...args: unknown[]) => string;
+}
+/**
+ * @deprecated 请使用 `CachedFunctionOptions`。保留旧名称仅为向后兼容。
+ */
+type CacheWrapOptions = CachedFunctionOptions;
+/**
+ * 将异步函数包装为带缓存的函数。
+ *
+ * 用户在源码中显式调用此函数声明缓存函数(无需 Vite 插件参与)。
+ *
+ * 工作流程:
+ * 1. 根据参数生成缓存键
+ * 2. 查询缓存 → 命中则返回反序列化的值
+ * 3. 未命中 → 在 `AsyncLocalStorage` 作用域中执行原函数
+ *    - 函数体内的 `cacheLife()` / `cacheTag()` 写入作用域
+ * 4. 将结果序列化存入缓存(带标签 + TTL)
+ * 5. 返回结果
+ *
+ * @example
+ * ```ts
+ * import { defineCachedFunction, cacheLife, cacheTag } from '@ubean/server';
+ *
+ * const getUser = defineCachedFunction(
+ *   async (id: string) => {
+ *     cacheLife(3600);
+ *     cacheTag('users', `user:${id}`);
+ *     return await db.query.user.findById(id);
+ *   },
+ *   { name: 'getUser' }
+ * );
+ * ```
+ *
+ * @param fn 原始异步函数
+ * @param options 缓存选项
+ */
+declare function defineCachedFunction<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>, options: CachedFunctionOptions): (...args: TArgs) => Promise<TResult>;
+/**
+ * @deprecated 请使用 `defineCachedFunction()`。保留旧名称仅为向后兼容。
+ */
+declare const wrapWithCache: typeof defineCachedFunction;
+/**
+ * 失效所有带指定标签的缓存条目。
+ *
+ * @example
+ * ```ts
+ * // 用户数据更新后,失效所有 'users' 标签的缓存
+ * await revalidateTag('users');
+ * ```
+ */
+declare function revalidateTag(tag: string): Promise<number>;
+/**
+ * 失效多个标签的缓存条目。
+ */
+declare function revalidateTags(...tags: string[]): Promise<number>;
+/**
+ * 失效缓存键匹配指定模式的条目。
+ *
+ * 支持 `*`(单段通配)和 `**`(多段通配)。
+ *
+ * @example
+ * ```ts
+ * // 失效所有 getUser 开头的缓存
+ * await revalidatePath('getUser:*');
+ * // 失效特定用户缓存
+ * await revalidatePath('getUser:["user-123"]');
+ * ```
+ */
+declare function revalidatePath(pattern: string | RegExp): Promise<number>;
+/**
+ * 清空所有组件级缓存。
+ */
+declare function clearComponentCache(): Promise<void>;
+//#endregion
+export { cacheLife as a, clearComponentCacheStore as c, revalidatePath as d, revalidateTag as f, wrapWithCache as h, ComponentCacheStore as i, createComponentMemoryStore as l, useComponentCacheStore as m, CachedFunctionOptions as n, cacheTag as o, revalidateTags as p, ComponentCacheEntry as r, clearComponentCache as s, CacheWrapOptions as t, defineCachedFunction as u };

package/dist/cache-directive.d.ts

@@ -0,0 +1,2 @@
+import { a as cacheLife, c as clearComponentCacheStore, d as revalidatePath, f as revalidateTag, h as wrapWithCache, i as ComponentCacheStore, l as createComponentMemoryStore, m as useComponentCacheStore, n as CachedFunctionOptions, o as cacheTag, p as revalidateTags, r as ComponentCacheEntry, s as clearComponentCache, t as CacheWrapOptions, u as defineCachedFunction } from "./cache-directive-CAxJAQyE.js";
+export { CacheWrapOptions, CachedFunctionOptions, ComponentCacheEntry, ComponentCacheStore, cacheLife, cacheTag, clearComponentCache, clearComponentCacheStore, createComponentMemoryStore, defineCachedFunction, revalidatePath, revalidateTag, revalidateTags, useComponentCacheStore, wrapWithCache };

package/dist/cache-directive.js

@@ -0,0 +1,2 @@
+import { a as createComponentMemoryStore, c as revalidateTag, d as wrapWithCache, i as clearComponentCacheStore, l as revalidateTags, n as cacheTag, o as defineCachedFunction, r as clearComponentCache, s as revalidatePath, t as cacheLife, u as useComponentCacheStore } from "./cache-directive-C1Nekkza.js";
+export { cacheLife, cacheTag, clearComponentCache, clearComponentCacheStore, createComponentMemoryStore, defineCachedFunction, revalidatePath, revalidateTag, revalidateTags, useComponentCacheStore, wrapWithCache };

package/dist/cache-entry.d.ts

@@ -0,0 +1,3 @@
+import { a as cacheLife, c as clearComponentCacheStore, d as revalidatePath, f as revalidateTag, h as wrapWithCache, i as ComponentCacheStore, l as createComponentMemoryStore, m as useComponentCacheStore, n as CachedFunctionOptions, o as cacheTag, p as revalidateTags, r as ComponentCacheEntry, s as clearComponentCache, t as CacheWrapOptions, u as defineCachedFunction } from "./cache-directive-CAxJAQyE.js";
+import { a as clearCacheStore, c as invalidateRouteCache, i as cachedEventHandler, l as resolveRouteCacheRules, n as CacheRule, o as createCacheMiddleware, r as CacheStore, s as createMemoryStore, t as CacheEntry, u as useCacheStore } from "./cache-b-MZlyv0.js";
+export { CacheEntry, CacheRule, CacheStore, CacheWrapOptions, CachedFunctionOptions, ComponentCacheEntry, ComponentCacheStore, cacheLife, cacheTag, cachedEventHandler, clearCacheStore, clearComponentCache, clearComponentCacheStore, createCacheMiddleware, createComponentMemoryStore, createMemoryStore, defineCachedFunction, invalidateRouteCache, resolveRouteCacheRules, revalidatePath, revalidateTag, revalidateTags, useCacheStore, useComponentCacheStore, wrapWithCache };

package/dist/cache-entry.js

@@ -0,0 +1,3 @@
+import { a as invalidateRouteCache, i as createMemoryStore, n as clearCacheStore, o as resolveRouteCacheRules, r as createCacheMiddleware, s as useCacheStore, t as cachedEventHandler } from "./cache-C84ix1Vq.js";
+import { a as createComponentMemoryStore, c as revalidateTag, d as wrapWithCache, i as clearComponentCacheStore, l as revalidateTags, n as cacheTag, o as defineCachedFunction, r as clearComponentCache, s as revalidatePath, t as cacheLife, u as useComponentCacheStore } from "./cache-directive-C1Nekkza.js";
+export { cacheLife, cacheTag, cachedEventHandler, clearCacheStore, clearComponentCache, clearComponentCacheStore, createCacheMiddleware, createComponentMemoryStore, createMemoryStore, defineCachedFunction, invalidateRouteCache, resolveRouteCacheRules, revalidatePath, revalidateTag, revalidateTags, useCacheStore, useComponentCacheStore, wrapWithCache };

package/dist/cron-entry.d.ts

@@ -0,0 +1,2 @@
+import { _ as runScheduledTask, a as resetCronRunCounts, c as CronContext, d as CronTaskMeta, f as ScheduledTask, g as getScheduledTasks, h as defineScheduled, i as parseCron, l as CronSchedule, m as createCronContext, n as SchedulerOptions, o as startCronScheduler, p as clearScheduledTasks, r as createMemoryCronScheduler, s as validateCron, t as CronScheduler, u as CronTaskDefinition } from "./cron-scheduler-BF33PPn4.js";
+export { CronContext, CronSchedule, CronScheduler, CronTaskDefinition, CronTaskMeta, ScheduledTask, SchedulerOptions, clearScheduledTasks, createCronContext, createMemoryCronScheduler, defineScheduled, getScheduledTasks, parseCron, resetCronRunCounts, runScheduledTask, startCronScheduler, validateCron };

package/dist/cron-entry.js

@@ -0,0 +1,2 @@
+import { a as validateCron, c as defineScheduled, i as startCronScheduler, l as getScheduledTasks, n as parseCron, o as clearScheduledTasks, r as resetCronRunCounts, s as createCronContext, t as createMemoryCronScheduler, u as runScheduledTask } from "./cron-scheduler-BVuXv7nn.js";
+export { clearScheduledTasks, createCronContext, createMemoryCronScheduler, defineScheduled, getScheduledTasks, parseCron, resetCronRunCounts, runScheduledTask, startCronScheduler, validateCron };

package/dist/cron-scheduler-BF33PPn4.d.ts

@@ -0,0 +1,77 @@
+//#region src/cron.d.ts
+type CronSchedule = string;
+interface CronTaskMeta {
+  name: string;
+  schedule: CronSchedule;
+  description?: string;
+  timezone?: string;
+  timeout?: number;
+  runOnStart?: boolean;
+}
+interface CronTaskDefinition extends CronTaskMeta {
+  handler: (ctx: CronContext) => void | Promise<void>;
+}
+interface CronContext {
+  name: string;
+  schedule: CronSchedule;
+  timestamp: Date;
+  runCount: number;
+}
+interface ScheduledTask {
+  name: string;
+  schedule: CronSchedule;
+  handler: (ctx: CronContext) => void | Promise<void>;
+  meta: Omit<CronTaskMeta, 'name' | 'schedule'>;
+}
+declare function defineScheduled(metaOrName: CronTaskMeta | string, handler?: (ctx: CronContext) => void | Promise<void>): ScheduledTask;
+declare function getScheduledTasks(): ScheduledTask[];
+declare function clearScheduledTasks(): void;
+declare function runScheduledTask(name: string): Promise<{
+  ok: boolean;
+  duration: number;
+  error?: Error;
+}>;
+declare function createCronContext(name: string, schedule: string): CronContext;
+//#endregion
+//#region src/cron-scheduler.d.ts
+interface CronScheduler {
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  runTask(name: string): Promise<{
+    ok: boolean;
+    duration: number;
+    error?: Error;
+  }>;
+  isRunning(): boolean;
+  getTasks(): ScheduledTask[];
+  getNextRuns(): Array<{
+    name: string;
+    nextRun: Date | null;
+  }>;
+}
+interface SchedulerOptions {
+  timezone?: string;
+  defaultTimeout?: number;
+  onTaskStart?: (task: ScheduledTask) => void;
+  onTaskComplete?: (task: ScheduledTask, result: {
+    ok: boolean;
+    duration: number;
+    error?: Error;
+  }) => void;
+  onTaskError?: (task: ScheduledTask, error: Error) => void;
+}
+type CronField = number[];
+interface ParsedCron {
+  minute: CronField;
+  hour: CronField;
+  dom: CronField;
+  month: CronField;
+  dow: CronField;
+}
+declare function parseCron(schedule: string): ParsedCron | null;
+declare function createMemoryCronScheduler(options?: SchedulerOptions): CronScheduler;
+declare function startCronScheduler(options?: SchedulerOptions): CronScheduler;
+declare function resetCronRunCounts(): void;
+declare function validateCron(schedule: string): boolean;
+//#endregion
+export { runScheduledTask as _, resetCronRunCounts as a, CronContext as c, CronTaskMeta as d, ScheduledTask as f, getScheduledTasks as g, defineScheduled as h, parseCron as i, CronSchedule as l, createCronContext as m, SchedulerOptions as n, startCronScheduler as o, clearScheduledTasks as p, createMemoryCronScheduler as r, validateCron as s, CronScheduler as t, CronTaskDefinition as u };

package/dist/cron-scheduler-BVuXv7nn.js

@@ -0,0 +1,258 @@
+//#region src/cron.ts
+const SCHEDULED_TASKS_KEY = "__ubean_scheduled_tasks__";
+const TASK_RUN_COUNT_KEY = "__ubean_task_run_count__";
+function getTaskMap() {
+	if (!globalThis[SCHEDULED_TASKS_KEY]) globalThis[SCHEDULED_TASKS_KEY] = /* @__PURE__ */ new Map();
+	return globalThis[SCHEDULED_TASKS_KEY];
+}
+function getTaskRunCount() {
+	if (!globalThis[TASK_RUN_COUNT_KEY]) globalThis[TASK_RUN_COUNT_KEY] = { value: 0 };
+	return globalThis[TASK_RUN_COUNT_KEY];
+}
+function defineScheduled(metaOrName, handler) {
+	let meta;
+	let fn;
+	if (typeof metaOrName === "string") {
+		meta = {
+			name: metaOrName,
+			schedule: "* * * * *"
+		};
+		fn = handler || (() => {});
+	} else {
+		meta = metaOrName;
+		fn = handler || (() => {});
+	}
+	if (!meta.name) throw new Error("[ubean] Cron task must have a name");
+	if (!meta.schedule) throw new Error(`[ubean] Cron task "${meta.name}" must have a schedule (cron expression)`);
+	const task = {
+		name: meta.name,
+		schedule: meta.schedule,
+		handler: fn,
+		meta: {
+			description: meta.description,
+			timezone: meta.timezone,
+			timeout: meta.timeout,
+			runOnStart: meta.runOnStart
+		}
+	};
+	getTaskMap().set(meta.name, task);
+	return task;
+}
+function getScheduledTasks() {
+	return Array.from(getTaskMap().values());
+}
+function clearScheduledTasks() {
+	getTaskMap().clear();
+}
+async function runScheduledTask(name) {
+	const task = getTaskMap().get(name);
+	if (!task) throw new Error(`[ubean] Cron task "${name}" not found`);
+	const runCount = ++getTaskRunCount().value;
+	const start = Date.now();
+	try {
+		const ctx = {
+			name: task.name,
+			schedule: task.schedule,
+			timestamp: /* @__PURE__ */ new Date(),
+			runCount
+		};
+		await task.handler(ctx);
+		return {
+			ok: true,
+			duration: Date.now() - start
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			duration: Date.now() - start,
+			error: err instanceof Error ? err : new Error(String(err))
+		};
+	}
+}
+function createCronContext(name, schedule) {
+	const runCount = ++getTaskRunCount().value;
+	return {
+		name,
+		schedule,
+		timestamp: /* @__PURE__ */ new Date(),
+		runCount
+	};
+}
+//#endregion
+//#region src/cron-scheduler.ts
+function parseField(field, min, max) {
+	const result = /* @__PURE__ */ new Set();
+	for (const part of field.split(",")) {
+		const trimmed = part.trim();
+		if (trimmed === "*") {
+			for (let i = min; i <= max; i++) result.add(i);
+			continue;
+		}
+		const stepMatch = trimmed.match(/^(.+)\/(\d+)$/);
+		let base = trimmed;
+		let step = 1;
+		if (stepMatch) {
+			base = stepMatch[1];
+			step = parseInt(stepMatch[2], 10);
+		}
+		if (base === "*") {
+			for (let i = min; i <= max; i += step) result.add(i);
+			continue;
+		}
+		const rangeMatch = base.match(/^(\d+)-(\d+)$/);
+		if (rangeMatch) {
+			const start = parseInt(rangeMatch[1], 10);
+			const end = parseInt(rangeMatch[2], 10);
+			for (let i = Math.max(min, start); i <= Math.min(max, end); i += step) result.add(i);
+			continue;
+		}
+		const value = parseInt(base, 10);
+		if (!isNaN(value) && value >= min && value <= max) result.add(value);
+	}
+	return Array.from(result).sort((a, b) => a - b);
+}
+function parseCron(schedule) {
+	const parts = schedule.trim().split(/\s+/);
+	if (parts.length < 5) return null;
+	const parsed = {
+		minute: parseField(parts[0], 0, 59),
+		hour: parseField(parts[1], 0, 23),
+		dom: parseField(parts[2], 1, 31),
+		month: parseField(parts[3], 1, 12),
+		dow: parseField(parts[4], 0, 6)
+	};
+	if (parsed.minute.length === 0 || parsed.hour.length === 0 || parsed.dom.length === 0 || parsed.month.length === 0 || parsed.dow.length === 0) return null;
+	return parsed;
+}
+function matches(date, parsed) {
+	return parsed.minute.includes(date.getMinutes()) && parsed.hour.includes(date.getHours()) && parsed.dom.includes(date.getDate()) && parsed.month.includes(date.getMonth() + 1) && parsed.dow.includes(date.getDay());
+}
+function nextMatch(from, parsed) {
+	const d = new Date(from);
+	d.setSeconds(0, 0);
+	d.setMinutes(d.getMinutes() + 1);
+	for (let i = 0; i < 527040; i++) {
+		if (matches(d, parsed)) return new Date(d);
+		d.setMinutes(d.getMinutes() + 1);
+	}
+	return null;
+}
+const taskRunCounts = /* @__PURE__ */ new Map();
+function getRunCount(name) {
+	const c = taskRunCounts.get(name) || 0;
+	taskRunCounts.set(name, c + 1);
+	return c + 1;
+}
+function createMemoryCronScheduler(options = {}) {
+	let timer = null;
+	let running = false;
+	const taskTimers = /* @__PURE__ */ new Map();
+	const runOnStartExecuted = /* @__PURE__ */ new Set();
+	async function executeTask(task) {
+		const ctx = {
+			name: task.name,
+			schedule: task.schedule,
+			timestamp: /* @__PURE__ */ new Date(),
+			runCount: getRunCount(task.name)
+		};
+		const start = Date.now();
+		options.onTaskStart?.(task);
+		try {
+			const timeoutMs = task.meta.timeout || options.defaultTimeout || 3e4;
+			await Promise.race([task.handler(ctx), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error(`Task "${task.name}" timed out after ${timeoutMs}ms`)), timeoutMs))]);
+			const result = {
+				ok: true,
+				duration: Date.now() - start
+			};
+			options.onTaskComplete?.(task, result);
+			return result;
+		} catch (err) {
+			const error = err instanceof Error ? err : new Error(String(err));
+			const result = {
+				ok: false,
+				duration: Date.now() - start,
+				error
+			};
+			options.onTaskError?.(task, error);
+			options.onTaskComplete?.(task, result);
+			return result;
+		}
+	}
+	function checkAndRun() {
+		const tasks = getScheduledTasks();
+		const now = /* @__PURE__ */ new Date();
+		for (const task of tasks) {
+			const parsed = parseCron(task.schedule);
+			if (!parsed) continue;
+			if (matches(now, parsed)) {
+				const timerKey = `${task.name}_${now.getFullYear()}-${now.getMonth()}-${now.getDate()}-${now.getHours()}-${now.getMinutes()}`;
+				if (taskTimers.has(timerKey)) continue;
+				if (runOnStartExecuted.has(task.name)) {
+					runOnStartExecuted.delete(task.name);
+					taskTimers.set(timerKey, setTimeout(() => {
+						taskTimers.delete(timerKey);
+					}, 6e4));
+					continue;
+				}
+				taskTimers.set(timerKey, setTimeout(() => {
+					taskTimers.delete(timerKey);
+				}, 6e4));
+				executeTask(task);
+			}
+		}
+	}
+	return {
+		async start() {
+			if (running) return;
+			running = true;
+			const tasks = getScheduledTasks();
+			for (const task of tasks) if (task.meta.runOnStart) {
+				runOnStartExecuted.add(task.name);
+				await executeTask(task);
+			}
+			timer = setInterval(checkAndRun, 3e4);
+		},
+		async stop() {
+			running = false;
+			if (timer) {
+				clearInterval(timer);
+				timer = null;
+			}
+			for (const t of taskTimers.values()) clearTimeout(t);
+			taskTimers.clear();
+		},
+		async runTask(name) {
+			const task = getScheduledTasks().find((t) => t.name === name);
+			if (!task) throw new Error(`[ubean] Cron task "${name}" not found`);
+			return executeTask(task);
+		},
+		isRunning() {
+			return running;
+		},
+		getTasks() {
+			return getScheduledTasks();
+		},
+		getNextRuns() {
+			return getScheduledTasks().map((task) => {
+				const parsed = parseCron(task.schedule);
+				return {
+					name: task.name,
+					nextRun: parsed ? nextMatch(/* @__PURE__ */ new Date(), parsed) : null
+				};
+			});
+		}
+	};
+}
+function startCronScheduler(options = {}) {
+	const scheduler = createMemoryCronScheduler(options);
+	scheduler.start();
+	return scheduler;
+}
+function resetCronRunCounts() {
+	taskRunCounts.clear();
+}
+function validateCron(schedule) {
+	return parseCron(schedule) !== null;
+}
+//#endregion
+export { validateCron as a, defineScheduled as c, startCronScheduler as i, getScheduledTasks as l, parseCron as n, clearScheduledTasks as o, resetCronRunCounts as r, createCronContext as s, createMemoryCronScheduler as t, runScheduledTask as u };

package/dist/database-CfpFznl-.d.ts

@@ -0,0 +1,67 @@
+//#region src/database.d.ts
+interface DatabaseHooks {
+  'db:connect': (db: Database) => void | Promise<void>;
+  'db:disconnect': (db: Database) => void | Promise<void>;
+  'db:query': (query: string, params?: unknown[]) => void | Promise<void>;
+  'db:error': (error: Error, query?: string) => void | Promise<void>;
+}
+interface Database {
+  sql: <T = Record<string, unknown>>(strings: TemplateStringsArray, ...values: unknown[]) => Promise<{
+    rows: T[];
+  }>;
+  exec: (query: string) => Promise<void>;
+  close: () => Promise<void>;
+}
+interface DatabaseConnector {
+  (options?: Record<string, unknown>): DatabaseConnectorInstance;
+}
+interface DatabaseConnectorInstance {
+  dialect?: string;
+  [key: string]: unknown;
+}
+interface DrizzleConfig {
+  schema?: Record<string, unknown>;
+  logger?: boolean | {
+    logQuery?: (query: string, params: unknown[]) => void;
+  };
+  casing?: 'camelCase' | 'snake_case';
+}
+interface DatabaseOptions {
+  connector?: DatabaseConnectorInstance;
+  connectors?: Record<string, DatabaseConnectorInstance>;
+  default?: string;
+}
+interface Migration {
+  name: string;
+  up: string;
+  down?: string;
+}
+declare const RAW_SQL: unique symbol;
+interface RawSqlValue {
+  [RAW_SQL]: true;
+  value: string;
+}
+declare function rawSql(str: string): RawSqlValue;
+type RawSqlFn = <T = Record<string, unknown>>(strings: TemplateStringsArray, ...values: unknown[]) => Promise<{
+  rows: T[];
+}>;
+type RawExecFn = (query: string) => Promise<void>;
+type RawCloseFn = () => Promise<void>;
+declare function defineDatabase(options?: DatabaseOptions): Database;
+declare function useDatabase(name?: string): Database;
+declare function closeDatabases(): Promise<void>;
+declare function getDatabaseHooks(): import("hookable").Hookable<DatabaseHooks, import("hookable").HookKeys<DatabaseHooks>>;
+declare function registerDb0Create(fn: (connector: DatabaseConnectorInstance) => {
+  sql: RawSqlFn;
+  exec: RawExecFn;
+  close: RawCloseFn;
+}): void;
+declare function migrateDatabase(db: Database, migrations: string[]): Promise<void>;
+declare function runMigrations(db: Database, migrations: Migration[], options?: {
+  table?: string;
+  log?: boolean;
+}): Promise<{
+  applied: string[];
+}>;
+//#endregion
+export { DatabaseOptions as a, closeDatabases as c, migrateDatabase as d, rawSql as f, useDatabase as h, DatabaseHooks as i, defineDatabase as l, runMigrations as m, DatabaseConnector as n, DrizzleConfig as o, registerDb0Create as p, DatabaseConnectorInstance as r, Migration as s, Database as t, getDatabaseHooks as u };