drizzle-cube 0.6.1 → 0.6.3

package/dist/adapters/{openai-B5jEiqiB.js → openai-CmMzrs1Y.js}

@@ -119,7 +119,7 @@ var ce = (e, t) => {
 	} catch {
 		return;
 	}
-}, ue = (e) => new Promise((t) => setTimeout(t, e)), de = "6.42.0", fe = () => typeof window < "u" && window.document !== void 0 && typeof navigator < "u";
+}, ue = (e) => new Promise((t) => setTimeout(t, e)), de = "6.44.0", fe = () => typeof window < "u" && window.document !== void 0 && typeof navigator < "u";
 function pe() {
 	return typeof Deno < "u" && Deno.build != null ? "deno" : typeof EdgeRuntime < "u" ? "edge" : Object.prototype.toString.call(globalThis.process === void 0 ? 0 : globalThis.process) === "[object process]" ? "node" : "unknown";
 }
@@ -1399,7 +1399,10 @@ I = /* @__PURE__ */ new WeakSet(), hn = function() {
 }, _n = function() {
 	for (let e = this.messages.length - 1; e >= 0; e--) {
 		let t = this.messages[e];
-		if (Qt(t) && t?.tool_calls?.length) return t.tool_calls.filter((e) => e.type === "function").at(-1)?.function;
+		if (Qt(t) && t?.tool_calls?.length) for (let e = t.tool_calls.length - 1; e >= 0; e--) {
+			let n = t.tool_calls[e];
+			if (n?.type === "function") return n.function;
+		}
 	}
 }, vn = function() {
 	for (let e = this.messages.length - 1; e >= 0; e--) {
@@ -2080,6 +2083,12 @@ var Gn = class extends N {
 			__security: { adminAPIKeyAuth: !0 }
 		});
 	}
+	retrieve(e, t) {
+		return this._client.get(P`/organization/spend_alerts/${e}`, {
+			...t,
+			__security: { adminAPIKeyAuth: !0 }
+		});
+	}
 	update(e, t, n) {
 		return this._client.post(P`/organization/spend_alerts/${e}`, {
 			body: t,
@@ -2469,6 +2478,13 @@ var nr = class extends N {
 			__security: { adminAPIKeyAuth: !0 }
 		});
 	}
+	retrieve(e, t, n) {
+		let { project_id: r } = t;
+		return this._client.get(P`/organization/projects/${r}/spend_alerts/${e}`, {
+			...n,
+			__security: { adminAPIKeyAuth: !0 }
+		});
+	}
 	update(e, t, n) {
 		let { project_id: r, ...i } = t;
 		return this._client.post(P`/organization/projects/${r}/spend_alerts/${e}`, {

package/dist/adapters/{openai-cDlFSTk6.js → openai-DhzGY9R4.js}

@@ -70,7 +70,7 @@ var r = class {
 		try {
 			let t = await import(
 				/* webpackIgnore: true */
-				"./openai-B5jEiqiB.js"
+				"./openai-CmMzrs1Y.js"
 );
 			e = t.default || t.OpenAI || t;
 		} catch {

package/dist/cjs/adapters/core/cube-http-handler.d.ts

@@ -0,0 +1,27 @@
+import { SemanticLayerCompiler } from '../../server/compiler.js';
+import { MCPOptions } from '../utils.js';
+import { HttpPort, McpHttpPort } from './http-port.js';
+import { BaseSecurityContextThunk } from './security-context.js';
+import { RestHandlers } from './rest-handlers.js';
+export type { BaseSecurityContextThunk } from './security-context.js';
+export interface CubeHttpHandlerOptions {
+    /** The semantic layer the handlers validate and execute against. */
+    semanticLayer: SemanticLayerCompiler;
+    /** Called in the REST `/load` catch-all 500 path with the thrown error (e.g. for logging). */
+    onError: (error: unknown) => void;
+    /**
+     * MCP endpoint config. Resolved once into the MCP POST handler. When omitted,
+     * MCP defaults are used; the adapter decides whether to route the MCP path.
+     */
+    mcp?: MCPOptions;
+}
+export interface CubeHttpHandler extends RestHandlers {
+    handleLoadGet<TRes>(port: HttpPort<TRes>, getBaseSecurityContext: BaseSecurityContextThunk): Promise<TRes>;
+    handleLoadPost<TRes>(port: HttpPort<TRes>, getBaseSecurityContext: BaseSecurityContextThunk): Promise<TRes>;
+    handleMcpPost<TRes>(port: McpHttpPort<TRes>, getBaseSecurityContext: BaseSecurityContextThunk): Promise<TRes>;
+}
+/**
+ * Build all HTTP handlers once. Each REST entry point owns its own request
+ * extraction, then funnels into a shared validate/execute/format tail.
+ */
+export declare function createCubeHttpHandler(options: CubeHttpHandlerOptions): CubeHttpHandler;

package/dist/cjs/adapters/core/http-port.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Framework port for the HTTP handler core.
+ *
+ * Captures the minimal transport surface a handler needs, generically over the
+ * framework's response type `TRes` so the same core works for adapters that
+ * mutate a response object (Express) and adapters that return a `Response`
+ * (Hono/Next.js). Implementations are constructed per request by each adapter.
+ *
+ * This interface is public — third parties implement it to build adapters for
+ * other frameworks. Add new capabilities as optional members or via a separate
+ * extension interface; a new required member is a breaking change.
+ */
+export interface HttpPort<TRes> {
+    /** Read a request header by (case-insensitive) name. Synchronous. */
+    getHeader(name: string): string | undefined;
+    /** Resolve the parsed request body. Async (Express resolves `req.body`; others await `.json()`). */
+    getBody(): Promise<unknown>;
+    /** Read a raw query-string value by name (used by GET). */
+    getQueryParam(name: string): string | undefined;
+    /** Send a response with the given status and JSON body; returns the framework's response value. */
+    send(status: number, body: unknown): TRes;
+}
+/**
+ * Extension of {@link HttpPort} for the MCP POST handler, which needs to set
+ * response headers (WWW-Authenticate, MCP-Session-Id), emit a single-event SSE
+ * response, and send an empty-body acknowledgement (202 for notifications).
+ *
+ * Kept separate from the minimal REST port so third-party adapters only
+ * implement these when they wire up MCP. New required members on this interface
+ * are still a breaking change for MCP-capable adapters.
+ */
+export interface McpHttpPort<TRes> extends HttpPort<TRes> {
+    /** Set a response header. Must be called before `send`/`sendSse`/`sendEmpty`. */
+    setHeader(name: string, value: string): void;
+    /** Send a single-event SSE response (status 200): write the pre-serialized body, then end. */
+    sendSse(status: number, body: string): TRes;
+    /** Send an empty-body response (no JSON), e.g. a 202 notification acknowledgement. */
+    sendEmpty(status: number): TRes;
+}

package/dist/cjs/adapters/core/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Public entry point for the framework-agnostic HTTP handler core.
+ *
+ * Third parties can build adapters for other frameworks by implementing
+ * {@link HttpPort} (REST) / {@link McpHttpPort} (MCP) and driving them with
+ * {@link createCubeHttpHandler}.
+ */
+export type { HttpPort, McpHttpPort } from './http-port.js';
+export { withLocaleFromHeaders, resolveSecurityContext, type HeaderReader, type BaseSecurityContextThunk } from './security-context.js';
+export { createCubeHttpHandler, type CubeHttpHandler, type CubeHttpHandlerOptions } from './cube-http-handler.js';
+export type { RestHandlers } from './rest-handlers.js';

package/dist/cjs/adapters/core/mcp-handler.d.ts

@@ -0,0 +1,13 @@
+import { SemanticLayerCompiler } from '../../server/compiler.js';
+import { MCPOptions } from '../utils.js';
+import { McpHttpPort } from './http-port.js';
+import { BaseSecurityContextThunk } from './security-context.js';
+export interface McpPostHandler {
+    handleMcpPost<TRes>(port: McpHttpPort<TRes>, getBaseSecurityContext: BaseSecurityContextThunk): Promise<TRes>;
+}
+/**
+ * Build the MCP POST handler once. Resolves the static resources/prompts/
+ * instructions and app config from {@link MCPOptions} at setup time, mirroring
+ * the per-request plumbing the adapters used to do inline.
+ */
+export declare function createMcpPostHandler(semanticLayer: SemanticLayerCompiler, mcp: MCPOptions): McpPostHandler;

package/dist/cjs/adapters/core/rest-handlers.d.ts

@@ -0,0 +1,14 @@
+import { SemanticLayerCompiler } from '../../server/compiler.js';
+import { HttpPort } from './http-port.js';
+import { BaseSecurityContextThunk } from './security-context.js';
+/** REST handlers keyed by endpoint; each closes over the shared semantic layer. */
+export interface RestHandlers {
+    handleMetaGet<TRes>(port: HttpPort<TRes>): TRes;
+    handleSqlGet<TRes>(port: HttpPort<TRes>, getBaseSecurityContext: BaseSecurityContextThunk): Promise<TRes>;
+    handleSqlPost<TRes>(port: HttpPort<TRes>, getBaseSecurityContext: BaseSecurityContextThunk): Promise<TRes>;
+    handleDryRunGet<TRes>(port: HttpPort<TRes>, getBaseSecurityContext: BaseSecurityContextThunk): Promise<TRes>;
+    handleDryRunPost<TRes>(port: HttpPort<TRes>, getBaseSecurityContext: BaseSecurityContextThunk): Promise<TRes>;
+    handleBatchPost<TRes>(port: HttpPort<TRes>, getBaseSecurityContext: BaseSecurityContextThunk): Promise<TRes>;
+    handleExplainPost<TRes>(port: HttpPort<TRes>, getBaseSecurityContext: BaseSecurityContextThunk): Promise<TRes>;
+}
+export declare function createRestHandlers(semanticLayer: SemanticLayerCompiler): RestHandlers;

package/dist/cjs/adapters/core/security-context.d.ts

@@ -0,0 +1,17 @@
+import { SecurityContext } from '../../server/index.js';
+/** Returns the base (pre-locale) security context for a request. */
+export type BaseSecurityContextThunk = () => SecurityContext | Promise<SecurityContext>;
+/** Reads a request header by (case-insensitive) name. */
+export type HeaderReader = (name: string) => string | undefined;
+/**
+ * Merge the request locale (from the `X-DC-Locale` header) into a base security
+ * context. Replaces the per-adapter `extractSecurityContextWithLocale` wrappers.
+ */
+export declare function withLocaleFromHeaders(base: SecurityContext, readHeader: HeaderReader): SecurityContext;
+/**
+ * Resolve the base security context and merge the request locale in one step —
+ * the standard preamble for every authenticated core handler.
+ */
+export declare function resolveSecurityContext(getBaseSecurityContext: BaseSecurityContextThunk, readHeader: HeaderReader): Promise<SecurityContext>;
+/** Strip CR/LF from a thrown value for single-line logging (log-injection guard). */
+export declare function sanitizeForLog(error: unknown): string;

package/dist/cjs/adapters/express/index.d.ts

@@ -0,0 +1,114 @@
+import { Router, Request, Response, Express } from 'express';
+import { CorsOptions } from 'cors';
+import { SemanticQuery, SecurityContext, DatabaseExecutor, DrizzleDatabase, Cube, CacheConfig, RLSSetupFn } from '../../server/index.js';
+import { AgentConfig } from '../../server/agent/types.js';
+import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
+import { MySql2Database } from 'drizzle-orm/mysql2';
+import { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
+import { MCPOptions } from '../utils.js';
+export interface ExpressAdapterOptions {
+    /**
+     * Array of cube definitions to register
+     */
+    cubes: Cube[];
+    /**
+     * Drizzle database instance (REQUIRED)
+     * This is the core of drizzle-cube - Drizzle ORM integration
+     * Accepts PostgreSQL, MySQL, or SQLite database instances
+     */
+    drizzle: PostgresJsDatabase<any> | MySql2Database<any> | BetterSQLite3Database<any> | DrizzleDatabase;
+    /**
+     * Database schema for type inference (RECOMMENDED)
+     * Provides full type safety for cube definitions
+     */
+    schema?: any;
+    /**
+     * Extract security context from incoming HTTP request.
+     * Called for EVERY API request to determine user permissions and multi-tenant isolation.
+     *
+     * This is your security boundary - ensure proper authentication and authorization here.
+     *
+     * @param req - Express Request object containing the incoming HTTP request
+     * @param res - Express Response object
+     * @returns Security context with organisationId, userId, roles, etc.
+     *
+     * @example
+     * extractSecurityContext: async (req, res) => {
+     *   // Extract JWT from Authorization header
+     *   const token = req.headers.authorization?.replace('Bearer ', '')
+     *   const decoded = await verifyJWT(token)
+     *
+     *   // Return context that will be available in all cube SQL functions
+     *   return {
+     *     organisationId: decoded.orgId,
+     *     userId: decoded.userId,
+     *     roles: decoded.roles
+     *   }
+     * }
+     */
+    extractSecurityContext: (req: Request, res: Response) => SecurityContext | Promise<SecurityContext>;
+    /**
+     * Database engine type (optional - auto-detected if not provided)
+     */
+    engineType?: 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'duckdb' | 'databend' | 'snowflake';
+    /**
+     * CORS configuration (optional)
+     */
+    cors?: CorsOptions;
+    /**
+     * API base path (default: '/cubejs-api/v1')
+     */
+    basePath?: string;
+    /**
+     * JSON body parser limit (default: '10mb')
+     */
+    jsonLimit?: string;
+    /**
+     * Cache configuration for query result caching
+     * When provided, query results will be cached using the specified provider
+     */
+    cache?: CacheConfig;
+    /**
+     * MCP (AI-Ready) endpoint configuration
+     * Enables AI agents to discover and query your data
+     * @default { enabled: true }
+     */
+    mcp?: MCPOptions;
+    /**
+     * Agent configuration for the agentic AI notebook feature.
+     * When provided, enables the POST /agent/chat SSE endpoint.
+     * Requires `@anthropic-ai/sdk` as a peer dependency.
+     */
+    agent?: AgentConfig;
+    /**
+     * Row-Level Security setup function.
+     * When provided, every query execution opens a transaction, calls this function
+     * to configure RLS (e.g., set JWT claims and switch Postgres roles), then runs the query.
+     */
+    rlsSetup?: RLSSetupFn;
+}
+/**
+ * Create Express router for Cube.js-compatible API
+ */
+export declare function createCubeRouter(options: ExpressAdapterOptions): Router;
+/**
+ * Convenience function to mount Cube routes on an existing Express app
+ */
+export declare function mountCubeRoutes(app: Express, options: ExpressAdapterOptions): Express;
+/**
+ * Create a complete Express app with Cube.js routes
+ *
+ * @example
+ * const app = createCubeApp({
+ *   cubes: [salesCube, employeesCube],
+ *   drizzle: db,
+ *   schema,
+ *   extractSecurityContext: async (req, res) => {
+ *     const token = req.headers.authorization?.replace('Bearer ', '')
+ *     const decoded = await verifyJWT(token)
+ *     return { organisationId: decoded.orgId, userId: decoded.userId }
+ *   }
+ * })
+ */
+export declare function createCubeApp(options: ExpressAdapterOptions): Express;
+export type { SecurityContext, DatabaseExecutor, SemanticQuery, DrizzleDatabase, CorsOptions };

package/dist/cjs/adapters/fastify/index.d.ts

@@ -0,0 +1,113 @@
+import { FastifyPluginCallback, FastifyRequest, FastifyInstance } from 'fastify';
+import { FastifyCorsOptions } from '@fastify/cors';
+import { SemanticQuery, SecurityContext, DatabaseExecutor, DrizzleDatabase, Cube, CacheConfig, RLSSetupFn } from '../../server/index.js';
+import { AgentConfig } from '../../server/agent/types.js';
+import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
+import { MySql2Database } from 'drizzle-orm/mysql2';
+import { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
+import { MCPOptions } from '../utils.js';
+export interface FastifyAdapterOptions {
+    /**
+     * Array of cube definitions to register
+     */
+    cubes: Cube[];
+    /**
+     * Drizzle database instance (REQUIRED)
+     * This is the core of drizzle-cube - Drizzle ORM integration
+     * Accepts PostgreSQL, MySQL, or SQLite database instances
+     */
+    drizzle: PostgresJsDatabase<any> | MySql2Database<any> | BetterSQLite3Database<any> | DrizzleDatabase;
+    /**
+     * Database schema for type inference (RECOMMENDED)
+     * Provides full type safety for cube definitions
+     */
+    schema?: any;
+    /**
+     * Extract security context from incoming HTTP request.
+     * Called for EVERY API request to determine user permissions and multi-tenant isolation.
+     *
+     * This is your security boundary - ensure proper authentication and authorization here.
+     *
+     * @param request - Fastify Request object containing the incoming HTTP request
+     * @returns Security context with organisationId, userId, roles, etc.
+     *
+     * @example
+     * extractSecurityContext: async (request) => {
+     *   // Extract JWT from Authorization header
+     *   const token = request.headers.authorization?.replace('Bearer ', '')
+     *   const decoded = await verifyJWT(token)
+     *
+     *   // Return context that will be available in all cube SQL functions
+     *   return {
+     *     organisationId: decoded.orgId,
+     *     userId: decoded.userId,
+     *     roles: decoded.roles
+     *   }
+     * }
+     */
+    extractSecurityContext: (request: FastifyRequest) => SecurityContext | Promise<SecurityContext>;
+    /**
+     * Database engine type (optional - auto-detected if not provided)
+     */
+    engineType?: 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'duckdb' | 'databend' | 'snowflake';
+    /**
+     * CORS configuration (optional)
+     */
+    cors?: FastifyCorsOptions;
+    /**
+     * API base path (default: '/cubejs-api/v1')
+     */
+    basePath?: string;
+    /**
+     * JSON body parser limit (default: 10485760 - 10MB)
+     */
+    bodyLimit?: number;
+    /**
+     * Cache configuration for query result caching
+     * When provided, query results will be cached using the specified provider
+     */
+    cache?: CacheConfig;
+    /**
+     * MCP (AI-Ready) endpoint configuration
+     * Enables AI agents to discover and query your data
+     * @default { enabled: true }
+     */
+    mcp?: MCPOptions;
+    /**
+     * Agent configuration for the agentic AI notebook feature.
+     * When provided, enables the POST /agent/chat SSE endpoint.
+     * Requires `@anthropic-ai/sdk` as a peer dependency.
+     */
+    agent?: AgentConfig;
+    /**
+     * Row-Level Security setup function.
+     * When provided, every query execution opens a transaction, calls this function
+     * to configure RLS (e.g., set JWT claims and switch Postgres roles), then runs the query.
+     */
+    rlsSetup?: RLSSetupFn;
+}
+/**
+ * Fastify plugin for Cube.js-compatible API
+ */
+export declare const cubePlugin: FastifyPluginCallback<FastifyAdapterOptions>;
+/**
+ * Helper function to register cube routes on an existing Fastify instance
+ */
+export declare function registerCubeRoutes(fastify: FastifyInstance, options: FastifyAdapterOptions): Promise<void>;
+/**
+ * Create a complete Fastify instance with Cube.js routes
+ *
+ * @example
+ * const app = createCubeApp({
+ *   cubes: [salesCube, employeesCube],
+ *   drizzle: db,
+ *   schema,
+ *   extractSecurityContext: async (request) => {
+ *     const token = request.headers.authorization?.replace('Bearer ', '')
+ *     const decoded = await verifyJWT(token)
+ *     return { organisationId: decoded.orgId, userId: decoded.userId }
+ *   }
+ * })
+ */
+export declare function createCubeApp(options: FastifyAdapterOptions): FastifyInstance;
+export type { SecurityContext, DatabaseExecutor, SemanticQuery, DrizzleDatabase, FastifyCorsOptions };

package/dist/cjs/adapters/hono/agent-handler.d.ts

@@ -0,0 +1,9 @@
+import { Context } from 'hono';
+import { SemanticLayerCompiler } from '../../server/compiler.js';
+import { SecurityContext } from '../../server/index.js';
+import { AgentConfig } from '../../server/agent/types.js';
+/**
+ * Handle a `POST /agent/chat` request: validate input, resolve the API key and
+ * overrides, then stream agent events as SSE. Mirrors the previous inline route.
+ */
+export declare function handleAgentChatRequest(c: Context, agentConfig: AgentConfig, semanticLayer: SemanticLayerCompiler, extractSecurityContext: (c: Context) => Promise<SecurityContext>): Promise<Response>;

package/dist/cjs/adapters/hono/index.d.ts

@@ -0,0 +1,120 @@
+import { Hono } from 'hono';
+import { SemanticQuery, SecurityContext, DatabaseExecutor, DrizzleDatabase, Cube, CacheConfig, RLSSetupFn } from '../../server/index.js';
+import { AgentConfig } from '../../server/agent/types.js';
+import { SemanticLayerCompiler } from '../../server/compiler.js';
+import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
+import { MySql2Database } from 'drizzle-orm/mysql2';
+import { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
+import { MCPOptions } from '../utils.js';
+export interface HonoAdapterOptions {
+    /**
+     * Array of cube definitions to register.
+     * Optional when `semanticLayer` is provided (caller manages registration).
+     */
+    cubes?: Cube[];
+    /**
+     * Pre-configured SemanticLayerCompiler instance.
+     * When provided, skips creating a new compiler and cube registration (caller manages it).
+     */
+    semanticLayer?: SemanticLayerCompiler;
+    /**
+     * Drizzle database instance.
+     * Required unless `semanticLayer` is provided.
+     * Accepts PostgreSQL, MySQL, or SQLite database instances.
+     */
+    drizzle?: PostgresJsDatabase<any> | MySql2Database<any> | BetterSQLite3Database<any> | DrizzleDatabase;
+    /**
+     * Database schema for type inference (RECOMMENDED)
+     * Provides full type safety for cube definitions
+     */
+    schema?: any;
+    /**
+     * Extract security context from incoming HTTP request.
+     * Called for EVERY API request to determine user permissions and multi-tenant isolation.
+     *
+     * This is your security boundary - ensure proper authentication and authorization here.
+     *
+     * @param c - Hono context containing the incoming HTTP request
+     * @returns Security context with organisationId, userId, roles, etc.
+     *
+     * @example
+     * extractSecurityContext: async (c) => {
+     *   // Extract JWT from Authorization header
+     *   const token = c.req.header('Authorization')?.replace('Bearer ', '')
+     *   const decoded = await verifyJWT(token)
+     *
+     *   // Return context that will be available in all cube SQL functions
+     *   return {
+     *     organisationId: decoded.orgId,
+     *     userId: decoded.userId,
+     *     roles: decoded.roles
+     *   }
+     * }
+     */
+    extractSecurityContext: (c: any) => SecurityContext | Promise<SecurityContext>;
+    /**
+     * Database engine type (optional - auto-detected if not provided)
+     */
+    engineType?: 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'duckdb' | 'databend' | 'snowflake';
+    /**
+     * CORS configuration (optional)
+     */
+    cors?: {
+        origin?: string | string[] | ((origin: string, c: any) => string | null | undefined);
+        allowMethods?: string[];
+        allowHeaders?: string[];
+        credentials?: boolean;
+    };
+    /**
+     * API base path (default: '/cubejs-api/v1')
+     */
+    basePath?: string;
+    /**
+     * Cache configuration for query result caching
+     * When provided, query results will be cached using the specified provider
+     */
+    cache?: CacheConfig;
+    /**
+     * MCP (AI-Ready) endpoint configuration
+     * Enables AI agents to discover and query your data
+     * @default { enabled: true }
+     */
+    mcp?: MCPOptions;
+    /**
+     * Agent configuration for the agentic AI notebook feature.
+     * When provided, enables the POST /agent/chat SSE endpoint.
+     * Requires `@anthropic-ai/sdk` as a peer dependency.
+     */
+    agent?: AgentConfig;
+    /**
+     * Row-Level Security setup function.
+     * When provided, every query execution opens a transaction, calls this function
+     * to configure RLS (e.g., set JWT claims and switch Postgres roles), then runs the query.
+     */
+    rlsSetup?: RLSSetupFn;
+}
+/**
+ * Create Hono routes for Cube.js-compatible API
+ */
+export declare function createCubeRoutes(options: HonoAdapterOptions): Hono<import('hono/types').BlankEnv, import('hono/types').BlankSchema, "/">;
+/**
+ * Convenience function to create routes and mount them on an existing Hono app
+ */
+export declare function mountCubeRoutes(app: Hono, options: HonoAdapterOptions): Hono<import('hono/types').BlankEnv, import('hono/types').BlankSchema, "/">;
+/**
+ * Create a complete Hono app with Cube.js routes
+ *
+ * @example
+ * const app = createCubeApp({
+ *   cubes: [salesCube, employeesCube],
+ *   drizzle: db,
+ *   schema,
+ *   extractSecurityContext: async (c) => {
+ *     const token = c.req.header('Authorization')
+ *     const decoded = await verifyJWT(token)
+ *     return { organisationId: decoded.orgId, userId: decoded.userId }
+ *   }
+ * })
+ */
+export declare function createCubeApp(options: HonoAdapterOptions): Hono<import('hono/types').BlankEnv, import('hono/types').BlankSchema, "/">;
+export type { SecurityContext, DatabaseExecutor, SemanticQuery, DrizzleDatabase };

package/dist/cjs/adapters/locale.d.ts

@@ -0,0 +1,8 @@
+import { SecurityContext } from '../server/index.js';
+export declare const DC_LOCALE_HEADER = "x-dc-locale";
+export declare const DEFAULT_LOCALE = "en-GB";
+type HeaderValue = string | string[] | null | undefined;
+export declare function resolveRequestLocale(getHeader: (name: string) => HeaderValue): string | undefined;
+export declare function withLocaleInSecurityContext(securityContext: SecurityContext, requestLocale?: string): SecurityContext;
+export declare function ensureLocaleHeader(allowHeaders?: string[] | string): string[];
+export {};

package/dist/cjs/adapters/mcp-tools-handlers.d.ts

@@ -0,0 +1,18 @@
+import { SemanticLayerCompiler, SecurityContext } from '../server/index.js';
+import { MCPToolResult } from './mcp-tools.js';
+export interface CubeToolHandlerDeps {
+    semanticLayer: SemanticLayerCompiler;
+    getSecurityContext: (meta?: unknown) => SecurityContext | Promise<SecurityContext>;
+    wrapContent: (result: unknown) => MCPToolResult;
+    wrapError: (error: unknown) => MCPToolResult;
+}
+/** Execute the `discover` tool. */
+export declare function runDiscoverTool(deps: CubeToolHandlerDeps, args: unknown): Promise<MCPToolResult>;
+/** Execute the `validate` tool — security context is optional (SQL omitted without auth). */
+export declare function runValidateTool(deps: CubeToolHandlerDeps, args: unknown, meta?: unknown): Promise<MCPToolResult>;
+/**
+ * Execute the `load` / `chart` tools. Both run the same query path; `chart`
+ * additionally carries `_meta.ui` on its definition so the result renders in the
+ * MCP App UI.
+ */
+export declare function runLoadTool(deps: CubeToolHandlerDeps, args: unknown, meta?: unknown): Promise<MCPToolResult>;