bunbase 0.0.9

package/dist/index.d.ts

@@ -0,0 +1,543 @@
+type DatabaseConfig = {
+	url: string;
+	debug?: boolean;
+};
+type LogLevel = "debug" | "info" | "warn" | "error" | "critical";
+type LoggerOptions = {
+	/** Minimum log level (default: 'info') */
+	level?: LogLevel;
+	/** Show verbose output with metadata details (default: false) */
+	verbose?: boolean;
+};
+type StorageConfig = {};
+import { Database } from "bun:sqlite";
+interface Job {
+	id?: number;
+	action_name: string;
+	trigger_name: string;
+	schedule: string;
+	status: "active" | "paused" | "completed";
+	last_run_at?: string | null;
+	next_run_at?: string | null;
+	run_count: number;
+	last_error?: string | null;
+	created_at?: string;
+}
+declare class JobStore {
+	private db;
+	constructor(db: Database);
+	/** Register or update a scheduled job */
+	upsert(job: {
+		action_name: string;
+		trigger_name: string;
+		schedule: string;
+	}): void;
+	/** Record a job execution */
+	recordRun(actionName: string, triggerName: string, error?: string): void;
+	/** Get all jobs */
+	list(status?: string): Job[];
+	/** Get a specific job */
+	get(actionName: string, triggerName: string): Job | null;
+	/** Pause a job */
+	pause(actionName: string, triggerName: string): void;
+	/** Resume a paused job */
+	resume(actionName: string, triggerName: string): void;
+}
+import { Database as Database2 } from "bun:sqlite";
+interface LogEntry {
+	id?: number;
+	level: string;
+	message: string;
+	meta?: string | null;
+	action_name?: string | null;
+	trace_id?: string | null;
+	created_at?: string;
+}
+interface LogFilter {
+	level?: string;
+	action_name?: string;
+	trace_id?: string;
+	limit?: number;
+	offset?: number;
+	since?: string;
+}
+declare class LogStore {
+	private db;
+	constructor(db: Database2);
+	insert(entry: Omit<LogEntry, "id" | "created_at">): void;
+	query(filter?: LogFilter): LogEntry[];
+	/** Delete logs older than given number of days */
+	cleanup(retentionDays: number): number;
+	count(filter?: LogFilter): number;
+}
+import { Database as Database3 } from "bun:sqlite";
+interface ActionRun {
+	id?: number;
+	trace_id: string;
+	action_name: string;
+	trigger_name: string;
+	trigger_type: string;
+	actor_id?: string | null;
+	actor_type?: string | null;
+	input?: string | null;
+	output?: string | null;
+	status: "pending" | "success" | "error";
+	error_message?: string | null;
+	duration_ms?: number | null;
+	started_at?: string;
+	completed_at?: string | null;
+}
+interface RunFilter {
+	action_name?: string;
+	trigger_type?: string;
+	status?: string;
+	limit?: number;
+	offset?: number;
+	since?: string;
+	until?: string;
+}
+declare class RunStore {
+	private db;
+	constructor(db: Database3);
+	/** Record the start of an action execution */
+	start(run: {
+		trace_id: string;
+		action_name: string;
+		trigger_name: string;
+		trigger_type: string;
+		actor_id?: string | null;
+		actor_type?: string | null;
+		input?: unknown;
+	}): void;
+	/** Mark an action run as completed successfully */
+	complete(traceId: string, output: unknown, durationMs: number): void;
+	/** Mark an action run as failed */
+	fail(traceId: string, errorMessage: string, durationMs: number): void;
+	/** Query action runs with filtering */
+	query(filter?: RunFilter): ActionRun[];
+	/** Get a single run by trace ID */
+	getByTraceId(traceId: string): ActionRun | null;
+	/** Get summary stats */
+	stats(since?: string): {
+		total: number;
+		success: number;
+		error: number;
+		avg_duration_ms: number;
+	};
+	/** Cleanup old runs */
+	cleanup(retentionDays: number): number;
+}
+import { Database as Database4 } from "bun:sqlite";
+interface StoreConfig {
+	/** Path to SQLite database file (default: '.gravity/data.db') */
+	path?: string;
+	/** Days to keep logs before auto-cleanup (default: 30) */
+	retention?: number;
+}
+declare class GravityStore {
+	readonly db: Database4;
+	readonly logs: LogStore;
+	readonly runs: RunStore;
+	readonly jobs: JobStore;
+	readonly retention: number;
+	constructor(config?: StoreConfig);
+	/** Run retention cleanup on all tables */
+	cleanup(): {
+		logs: number;
+		runs: number;
+	};
+	/** Close the database connection */
+	close(): void;
+}
+interface GravityConfig {
+	/**
+	* Project name (used for logging, defaults, etc.)
+	*/
+	name?: string;
+	/**
+	* Server configuration
+	*/
+	server?: {
+		port?: number;
+		host?: string;
+		cors?: {
+			origin?: string | string[];
+			credentials?: boolean;
+		};
+	};
+	/**
+	* Database configuration
+	*/
+	db?: DatabaseConfig;
+	/**
+	* Storage configuration
+	*/
+	storage?: StorageConfig;
+	/**
+	* Logger configuration
+	*/
+	logger?: LoggerOptions;
+	/**
+	* Persistence store configuration (bun:sqlite)
+	*/
+	store?: StoreConfig;
+	/**
+	* Actions directory (default: './src/actions' or './actions')
+	*/
+	actionsDir?: string;
+	/**
+	* OpenAPI/docs generation
+	*/
+	docs?: {
+		enabled?: boolean;
+		path?: string;
+		title?: string;
+		version?: string;
+	};
+	/**
+	* MCP server configuration
+	*/
+	mcp?: {
+		enabled?: boolean;
+		name?: string;
+		version?: string;
+	};
+	/**
+	* Development server options
+	*/
+	dev?: {
+		watch?: boolean;
+		hmr?: boolean;
+	};
+	/**
+	* Custom middleware or hooks
+	*/
+	plugins?: GravityPlugin[];
+}
+interface GravityPlugin {
+	name: string;
+	setup: (context: GravityPluginContext) => Promise<void> | void;
+}
+interface GravityPluginContext {
+	config: GravityConfig;
+}
+declare function loadConfig(): Promise<GravityConfig>;
+declare function defineConfig(config: GravityConfig): GravityConfig;
+import { TSchema as TSchema2 } from "typebox";
+import { Static, TSchema } from "typebox";
+/**
+* A structured logging session with clack-style box-drawing output.
+* Created via `logger.session("title")`.
+*/
+declare class LoggerSession {
+	private output;
+	private startTime;
+	constructor(title: string, output?: NodeJS.WritableStream);
+	private write;
+	/** Static info line: ◇  label: detail */
+	info(label: string, detail?: string): this;
+	/** In-progress step: ●  label: detail */
+	step(label: string, detail?: string): this;
+	/** Completed step: ✔  label: detail */
+	success(label: string, detail?: string): this;
+	/** Warning step: ▲  label: detail */
+	warn(label: string, detail?: string): this;
+	/** Error step: ✖  label: detail */
+	error(label: string, detail?: string): this;
+	/** Empty separator bar: │ */
+	bar(): this;
+	/** Close the session with success: └  message (Xms) */
+	end(message?: string): void;
+	/** Close the session as error: └  message (Xms) */
+	fail(message?: string): void;
+}
+declare const LEVELS: {
+	readonly DEBUG: 10;
+	readonly INFO: 20;
+	readonly WARNING: 30;
+	readonly ERROR: 40;
+	readonly CRITICAL: 50;
+};
+type LogLevel2 = keyof typeof LEVELS;
+type LogListener = (level: LogLevel2, msg: string, args?: unknown) => void;
+declare class Logger {
+	private readonly options;
+	private readonly meta;
+	private readonly coreListeners;
+	private readonly listeners;
+	private readonly minLevel;
+	private store?;
+	constructor(options?: LoggerOptions, meta?: Record<string, unknown>, coreListeners?: LogListener[], store?: GravityStore);
+	/** Attach a persistence store for log persistence */
+	setStore(store: GravityStore): void;
+	/** Create a child logger with additional metadata */
+	child(meta: Record<string, unknown>): Logger;
+	/** Start a structured logging session with clack-style output */
+	session(title: string): LoggerSession;
+	private shouldLog;
+	private _log;
+	info(message: string, args?: unknown): void;
+	error(message: string, args?: unknown): void;
+	debug(message: string, args?: unknown): void;
+	warn(message: string, args?: unknown): void;
+	addListener(listener: LogListener): void;
+}
+type TriggerKind = "api" | "cron" | "event" | "agent";
+interface BaseTrigger<TKind extends TriggerKind = TriggerKind> {
+	kind: TKind;
+	name: string;
+	/**
+	* Transform source data into action input
+	*/
+	map?: (source: never) => unknown | Promise<unknown>;
+	/**
+	* Resolve actor from source data or provide static actor
+	*/
+	actor?: GravityActor | ((source: never) => GravityActor | Promise<GravityActor>);
+}
+interface ApiTrigger extends BaseTrigger<"api"> {
+	method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+	path: string;
+	/**
+	* Map HTTP request to action input
+	* Default: body for POST/PUT/PATCH, query for GET/DELETE
+	*/
+	map?: (req: ApiRequest) => unknown | Promise<unknown>;
+	/**
+	* Extract actor from request (session, JWT, API key, etc.)
+	*/
+	actor?: GravityActor | ((req: ApiRequest) => GravityActor | Promise<GravityActor>);
+}
+interface ApiRequest {
+	method: string;
+	path: string;
+	params: Record<string, string | undefined>;
+	query: Record<string, string>;
+	body: unknown;
+	headers: Record<string, string>;
+	raw?: unknown;
+}
+interface CronTrigger extends BaseTrigger<"cron"> {
+	/**
+	* Cron expression (e.g., '0 * * * *')
+	*/
+	schedule: string;
+	/**
+	* Timezone (default: UTC)
+	*/
+	timezone?: string;
+	/**
+	* Provide static input for cron jobs
+	*/
+	map?: () => unknown | Promise<unknown>;
+}
+interface EventTrigger extends BaseTrigger<"event"> {
+	/**
+	* Event pattern to match (e.g., 'order.created', 'user.*')
+	*/
+	event: string;
+	/**
+	* Map event payload to action input
+	*/
+	map?: (event: GravityEvent) => unknown | Promise<unknown>;
+	/**
+	* Extract actor from event metadata
+	*/
+	actor?: GravityActor | ((event: GravityEvent) => GravityActor | Promise<GravityActor>);
+}
+interface GravityEvent<T = unknown> {
+	id: string;
+	type: string;
+	data: T;
+	timestamp: Date;
+	actor?: GravityActor;
+	metadata?: Record<string, unknown>;
+}
+interface AgentTrigger extends BaseTrigger<"agent"> {
+	/**
+	* MCP tool name
+	*/
+	tool: string;
+	/**
+	* Tool description for LLM
+	*/
+	description: string;
+	/**
+	* Map MCP call arguments to action input
+	*/
+	map?: (args: Record<string, unknown>) => unknown | Promise<unknown>;
+	/**
+	* Extract actor from MCP context
+	*/
+	actor?: GravityActor | ((context: McpContext) => GravityActor | Promise<GravityActor>);
+}
+interface McpContext {
+	toolName: string;
+	args: Record<string, unknown>;
+	sessionId?: string;
+	metadata?: Record<string, unknown>;
+}
+type Trigger = ApiTrigger | CronTrigger | EventTrigger | AgentTrigger;
+type ApiTriggerOptions = {
+	map?: (req: ApiRequest) => unknown | Promise<unknown>;
+	actor?: GravityActor | ((req: ApiRequest) => GravityActor | Promise<GravityActor>);
+};
+type ApiTriggerBuilder = {
+	(method: ApiTrigger["method"], path: string, options?: ApiTriggerOptions): ApiTrigger;
+	get: (path: string, options?: Omit<ApiTriggerOptions, never>) => ApiTrigger;
+	post: (path: string, options?: Omit<ApiTriggerOptions, never>) => ApiTrigger;
+	put: (path: string, options?: Omit<ApiTriggerOptions, never>) => ApiTrigger;
+	patch: (path: string, options?: Omit<ApiTriggerOptions, never>) => ApiTrigger;
+	delete: (path: string, options?: Omit<ApiTriggerOptions, never>) => ApiTrigger;
+};
+declare const api: ApiTriggerBuilder;
+declare function cron(schedule: string, options?: {
+	timezone?: string;
+	map?: () => unknown | Promise<unknown>;
+	actor?: GravityActor;
+}): CronTrigger;
+declare function event(eventPattern: string, options?: {
+	map?: (event: GravityEvent) => unknown | Promise<unknown>;
+	actor?: GravityActor | ((event: GravityEvent) => GravityActor | Promise<GravityActor>);
+}): EventTrigger;
+declare function agent(tool: string, description: string, options?: {
+	map?: (args: Record<string, unknown>) => unknown | Promise<unknown>;
+	actor?: GravityActor | ((context: McpContext) => GravityActor | Promise<GravityActor>);
+}): AgentTrigger;
+/**
+* The Standard Identity Structure for Basalt
+*/
+interface GravityActor {
+	type: "user" | "agent" | "system" | "public";
+	id?: string;
+	name?: string;
+	roles?: string[];
+	metadata?: Record<string, unknown>;
+}
+type Actor = GravityActor;
+/**
+* The Unified Trigger Contract
+*/
+/**
+* Auth context resolved by the auth provider.
+* Augmented via .gravity/types.d.ts module augmentation.
+*/
+type GravityAuthContext = {};
+interface Organization {
+	id: string;
+	plan?: string;
+	[key: string]: any;
+}
+interface JobOptions {
+	delay?: string | number;
+}
+type BaseActionContext = {
+	db: any;
+	storage: any;
+	enqueue: (event: string, input: any) => void | Promise<void>;
+	schedule: <
+		TInput extends TSchema,
+		TOutput extends TSchema
+	>(when: number | Date | string, action: Action<TInput, TOutput>, input: Static<TInput>) => void | Promise<void>;
+	logger: Logger;
+};
+type ExtendActionContext = {};
+type ActionContext = {
+	actor: GravityActor;
+	org?: Organization;
+	triggerName: string;
+	triggerType: TriggerKind;
+	traceId: string;
+} & BaseActionContext & ExtendActionContext;
+interface RateLimitRule {
+	/** How many requests */
+	limit: number;
+	/** Time window, e.g., "1s", "1m", "1h" */
+	window: string;
+	/** What to group by: 'actor' (user), 'org' (tenant), or 'ip' (guest) */
+	by: "actor" | "org" | "ip";
+	/** Optional: custom identifier, e.g., 'ai-budget' */
+	name?: string;
+}
+type RateLimitConfig = RateLimitRule | RateLimitRule[];
+type ActionRateLimit = RateLimitConfig | {
+	common?: RateLimitConfig;
+	api?: RateLimitConfig;
+	agent?: RateLimitConfig;
+	[key: string]: RateLimitConfig | undefined;
+};
+interface AccessConfig {
+	common?: {
+		authenticated?: boolean;
+	};
+	api?: {
+		roles?: string[];
+	};
+	agent?: {
+		authenticated?: boolean;
+	};
+	authenticated?: boolean;
+	roles?: string[];
+}
+type GuardFunction<TInput> = (input: TInput, ctx: ActionContext) => boolean | Promise<boolean>;
+interface GuardConfig<TInput> {
+	api?: GuardFunction<TInput>;
+	event?: GuardFunction<TInput>;
+	cron?: GuardFunction<TInput>;
+	agent?: GuardFunction<TInput>;
+	[key: string]: GuardFunction<TInput> | undefined;
+}
+interface ActionConfig<
+	TInput extends TSchema = TSchema,
+	TOutput extends TSchema = TSchema
+> {
+	name: string;
+	description?: string;
+	input?: TInput;
+	output?: TOutput;
+	triggers?: Trigger[];
+	access?: AccessConfig;
+	guard?: GuardConfig<Static<TInput>>;
+	rateLimit?: ActionRateLimit;
+}
+type ActionHandler<
+	TInput extends TSchema,
+	TOutput extends TSchema
+> = (input: Static<TInput>, ctx: ActionContext) => Promise<Static<TOutput>>;
+interface Action<
+	TInput extends TSchema = TSchema,
+	TOutput extends TSchema = TSchema
+> {
+	config: ActionConfig<TInput, TOutput>;
+	handler: ActionHandler<TInput, TOutput>;
+	(input: Static<TInput>, ctx: ActionContext): Promise<Static<TOutput>>;
+}
+declare function action<
+	TInput extends TSchema2 = TSchema2,
+	TOutput extends TSchema2 = TSchema2
+>(config: ActionConfig<TInput, TOutput>, handler: ActionHandler<TInput, TOutput>): Action<TInput, TOutput>;
+declare class GravityError extends Error {
+	code: string;
+	status: number;
+	constructor(message: string, code: string, status: number);
+}
+declare class NotFoundError extends GravityError {
+	constructor(message?: string);
+}
+declare class UnauthorizedError extends GravityError {
+	constructor(message?: string);
+}
+declare class ForbiddenError extends GravityError {
+	constructor(message?: string);
+}
+declare class BadRequestError extends GravityError {
+	constructor(message?: string);
+}
+declare class InternalServerError extends GravityError {
+	constructor(message?: string);
+}
+declare class NonRetriableError extends GravityError {
+	constructor(message: string);
+}
+import { Type } from "typebox";
+export { Type as t, loadConfig, event, defineConfig, cron, api, agent, action, UnauthorizedError, TriggerKind, Trigger, RateLimitRule, RateLimitConfig, Organization, NotFoundError, NonRetriableError, McpContext, JobOptions, InternalServerError, GuardFunction, GuardConfig, GravityEvent, GravityError, GravityAuthContext, GravityActor, ForbiddenError, ExtendActionContext, EventTrigger, CronTrigger, BaseTrigger, BaseActionContext, BadRequestError, ApiTrigger, ApiRequest, AgentTrigger, Actor, ActionRateLimit, ActionHandler, ActionContext, ActionConfig, Action, AccessConfig };

package/dist/index.js

@@ -0,0 +1,164 @@
+import {
+  BadRequestError,
+  ForbiddenError,
+  GravityError,
+  InternalServerError,
+  NonRetriableError,
+  NotFoundError,
+  UnauthorizedError,
+  defineConfig,
+  loadConfig
+} from "./shared/chunk-k195ahh5.js";
+// src/core/action.ts
+import { Value } from "typebox/value";
+function resolveRateLimitRules(config, triggerType) {
+  if (!config)
+    return [];
+  let rules;
+  if ("limit" in config || Array.isArray(config)) {
+    rules = config;
+  } else {
+    const structured = config;
+    const specific = structured[triggerType];
+    const common = structured.common;
+    if (specific && common) {
+      const sRules = Array.isArray(specific) ? specific : [specific];
+      const cRules = Array.isArray(common) ? common : [common];
+      return [...cRules, ...sRules];
+    }
+    rules = specific || common;
+  }
+  if (!rules)
+    return [];
+  return Array.isArray(rules) ? rules : [rules];
+}
+async function checkRateLimit(ctx, config) {
+  if (!config.rateLimit)
+    return;
+  const rules = resolveRateLimitRules(config.rateLimit, ctx.triggerType);
+  if (rules.length === 0)
+    return;
+  for (const rule of rules) {}
+}
+async function checkAccess(ctx, access) {
+  if (ctx.actor.type === "system")
+    return;
+  let config = { ...access.common };
+  if (ctx.triggerType === "api" && access.api) {
+    config = { ...config, ...access.api };
+  } else if (ctx.triggerType === "agent" && access.agent) {
+    config = { ...config, ...access.agent };
+  }
+  if (Object.keys(config).length === 0 && (access.authenticated !== undefined || access.roles)) {
+    config = {
+      authenticated: access.authenticated,
+      roles: access.roles
+    };
+  }
+  if (config.authenticated) {
+    if (ctx.actor.type === "public") {
+      throw new UnauthorizedError("Authentication required");
+    }
+  }
+  if (config.roles && config.roles.length > 0) {
+    if (ctx.actor.type === "public") {
+      throw new UnauthorizedError("Authentication required");
+    }
+    const userRoles = ctx.actor.roles || [];
+    const hasRole = config.roles.some((role) => userRoles.includes(role));
+    if (!hasRole) {
+      throw new ForbiddenError(`User lacks required role(s): ${config.roles.join(", ")}`);
+    }
+  }
+}
+async function checkGuard(ctx, input, config) {
+  if (!config.guard)
+    return;
+  const guardFn = config.guard[ctx.triggerName] || config.guard[ctx.triggerType];
+  if (guardFn) {
+    const allowed = await guardFn(input, ctx);
+    if (!allowed) {
+      throw new ForbiddenError("Guard check failed");
+    }
+  }
+}
+function action(config, handler) {
+  const wrapped = async (input, ctx) => {
+    try {
+      if (config.input && !Value.Check(config.input, input)) {
+        const errors = [...Value.Errors(config.input, input)];
+        throw new BadRequestError(`Validation Error: ${JSON.stringify(errors)}`);
+      }
+      await checkRateLimit(ctx, config);
+      if (config.access) {
+        await checkAccess(ctx, config.access);
+      }
+      await checkGuard(ctx, input, config);
+      return await handler(input, ctx);
+    } catch (error) {
+      throw error;
+    }
+  };
+  wrapped.config = config;
+  wrapped.handler = handler;
+  return wrapped;
+}
+// src/triggers/index.ts
+var api = (method, path, options) => {
+  return {
+    kind: "api",
+    name: `api:${method}:${path}`,
+    method,
+    path,
+    ...options
+  };
+};
+api.get = (path, options) => api("GET", path, options);
+api.post = (path, options) => api("POST", path, options);
+api.put = (path, options) => api("PUT", path, options);
+api.patch = (path, options) => api("PATCH", path, options);
+api.delete = (path, options) => api("DELETE", path, options);
+function cron(schedule, options) {
+  return {
+    kind: "cron",
+    name: `cron:${schedule}`,
+    schedule,
+    ...options
+  };
+}
+function event(eventPattern, options) {
+  return {
+    kind: "event",
+    name: `event:${eventPattern}`,
+    event: eventPattern,
+    ...options
+  };
+}
+function agent(tool, description, options) {
+  return {
+    kind: "agent",
+    name: `agent:${tool}`,
+    tool,
+    description,
+    ...options
+  };
+}
+// src/utils/typebox.ts
+import { Type } from "typebox";
+export {
+  Type as t,
+  loadConfig,
+  event,
+  defineConfig,
+  cron,
+  api,
+  agent,
+  action,
+  UnauthorizedError,
+  NotFoundError,
+  NonRetriableError,
+  InternalServerError,
+  GravityError,
+  ForbiddenError,
+  BadRequestError
+};