drizzle-cube 0.1.18 → 0.1.19

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

@@ -4,22 +4,22 @@ import { SemanticQuery, SecurityContext, DatabaseExecutor, DrizzleDatabase, Cube
 import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
 import { MySql2Database } from 'drizzle-orm/mysql2';
 import { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
-export interface ExpressAdapterOptions<TSchema extends Record<string, any> = Record<string, any>> {
+export interface ExpressAdapterOptions {
     /**
      * Array of cube definitions to register
      */
-    cubes: Cube<TSchema>[];
+    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<TSchema> | MySql2Database<TSchema> | BetterSQLite3Database<TSchema> | DrizzleDatabase<TSchema>;
+    drizzle: PostgresJsDatabase<any> | MySql2Database<any> | BetterSQLite3Database<any> | DrizzleDatabase;
     /**
      * Database schema for type inference (RECOMMENDED)
      * Provides full type safety for cube definitions
      */
-    schema?: TSchema;
+    schema?: any;
     /**
      * Extract security context from incoming HTTP request.
      * Called for EVERY API request to determine user permissions and multi-tenant isolation.
@@ -65,11 +65,11 @@ export interface ExpressAdapterOptions<TSchema extends Record<string, any> = Rec
 /**
  * Create Express router for Cube.js-compatible API
  */
-export declare function createCubeRouter<TSchema extends Record<string, any> = Record<string, any>>(options: ExpressAdapterOptions<TSchema>): Router;
+export declare function createCubeRouter(options: ExpressAdapterOptions): Router;
 /**
  * Convenience function to mount Cube routes on an existing Express app
  */
-export declare function mountCubeRoutes<TSchema extends Record<string, any> = Record<string, any>>(app: Express, options: ExpressAdapterOptions<TSchema>): Express;
+export declare function mountCubeRoutes(app: Express, options: ExpressAdapterOptions): Express;
 /**
  * Create a complete Express app with Cube.js routes
  *
@@ -85,5 +85,5 @@ export declare function mountCubeRoutes<TSchema extends Record<string, any> = Re
  *   }
  * })
  */
-export declare function createCubeApp<TSchema extends Record<string, any> = Record<string, any>>(options: ExpressAdapterOptions<TSchema>): Express;
+export declare function createCubeApp(options: ExpressAdapterOptions): Express;
 export type { SecurityContext, DatabaseExecutor, SemanticQuery, DrizzleDatabase, CorsOptions };

package/dist/adapters/express/index.js

@@ -1,6 +1,6 @@
 import Q, { Router as E } from "express";
 import R from "cors";
-import { S as $, c as a, f as v, a as L, b as x, h } from "../compiler-Dec55JjO.js";
+import { S as $, c as a, f as v, a as L, b as x, h } from "../compiler-CPsEzFP2.js";
 function N(l) {
   const {
     cubes: c,

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

@@ -4,22 +4,22 @@ import { SemanticQuery, SecurityContext, DatabaseExecutor, DrizzleDatabase, Cube
 import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
 import { MySql2Database } from 'drizzle-orm/mysql2';
 import { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
-export interface FastifyAdapterOptions<TSchema extends Record<string, any> = Record<string, any>> {
+export interface FastifyAdapterOptions {
     /**
      * Array of cube definitions to register
      */
-    cubes: Cube<TSchema>[];
+    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<TSchema> | MySql2Database<TSchema> | BetterSQLite3Database<TSchema> | DrizzleDatabase<TSchema>;
+    drizzle: PostgresJsDatabase<any> | MySql2Database<any> | BetterSQLite3Database<any> | DrizzleDatabase;
     /**
      * Database schema for type inference (RECOMMENDED)
      * Provides full type safety for cube definitions
      */
-    schema?: TSchema;
+    schema?: any;
     /**
      * Extract security context from incoming HTTP request.
      * Called for EVERY API request to determine user permissions and multi-tenant isolation.
@@ -68,7 +68,7 @@ export declare const cubePlugin: FastifyPluginCallback<FastifyAdapterOptions>;
 /**
  * Helper function to register cube routes on an existing Fastify instance
  */
-export declare function registerCubeRoutes<TSchema extends Record<string, any> = Record<string, any>>(fastify: FastifyInstance, options: FastifyAdapterOptions<TSchema>): Promise<void>;
+export declare function registerCubeRoutes(fastify: FastifyInstance, options: FastifyAdapterOptions): Promise<void>;
 /**
  * Create a complete Fastify instance with Cube.js routes
  *
@@ -84,5 +84,5 @@ export declare function registerCubeRoutes<TSchema extends Record<string, any> =
  *   }
  * })
  */
-export declare function createCubeApp<TSchema extends Record<string, any> = Record<string, any>>(options: FastifyAdapterOptions<TSchema>): FastifyInstance;
+export declare function createCubeApp(options: FastifyAdapterOptions): FastifyInstance;
 export type { SecurityContext, DatabaseExecutor, SemanticQuery, DrizzleDatabase, FastifyCorsOptions };

package/dist/adapters/fastify/index.js

@@ -1,4 +1,4 @@
-import { S as P, c as u, f as v, a as L, b as Q, h as C } from "../compiler-Dec55JjO.js";
+import { S as P, c as u, f as v, a as L, b as Q, h as C } from "../compiler-CPsEzFP2.js";
 const w = function(o, x, q) {
   const {
     cubes: b,

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

@@ -3,22 +3,22 @@ import { SemanticQuery, SecurityContext, DatabaseExecutor, DrizzleDatabase, Cube
 import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
 import { MySql2Database } from 'drizzle-orm/mysql2';
 import { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
-export interface HonoAdapterOptions<TSchema extends Record<string, any> = Record<string, any>> {
+export interface HonoAdapterOptions {
     /**
      * Array of cube definitions to register
      */
-    cubes: Cube<TSchema>[];
+    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<TSchema> | MySql2Database<TSchema> | BetterSQLite3Database<TSchema> | DrizzleDatabase<TSchema>;
+    drizzle: PostgresJsDatabase<any> | MySql2Database<any> | BetterSQLite3Database<any> | DrizzleDatabase;
     /**
      * Database schema for type inference (RECOMMENDED)
      * Provides full type safety for cube definitions
      */
-    schema?: TSchema;
+    schema?: any;
     /**
      * Extract security context from incoming HTTP request.
      * Called for EVERY API request to determine user permissions and multi-tenant isolation.
@@ -64,11 +64,11 @@ export interface HonoAdapterOptions<TSchema extends Record<string, any> = Record
 /**
  * Create Hono routes for Cube.js-compatible API
  */
-export declare function createCubeRoutes<TSchema extends Record<string, any> = Record<string, any>>(options: HonoAdapterOptions<TSchema>): Hono<import('hono/types').BlankEnv, import('hono/types').BlankSchema, "/">;
+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<TSchema extends Record<string, any> = Record<string, any>>(app: Hono, options: HonoAdapterOptions<TSchema>): Hono<import('hono/types').BlankEnv, import('hono/types').BlankSchema, "/">;
+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
  *
@@ -84,5 +84,5 @@ export declare function mountCubeRoutes<TSchema extends Record<string, any> = Re
  *   }
  * })
  */
-export declare function createCubeApp<TSchema extends Record<string, any> = Record<string, any>>(options: HonoAdapterOptions<TSchema>): Hono<import('hono/types').BlankEnv, import('hono/types').BlankSchema, "/">;
+export declare function createCubeApp(options: HonoAdapterOptions): Hono<import('hono/types').BlankEnv, import('hono/types').BlankSchema, "/">;
 export type { SecurityContext, DatabaseExecutor, SemanticQuery, DrizzleDatabase };

package/dist/adapters/hono/index.js

@@ -1,5 +1,5 @@
 import { Hono as x } from "hono";
-import { S as v, f as h, a as A, b as w, h as C } from "../compiler-Dec55JjO.js";
+import { S as v, f as h, a as A, b as w, h as C } from "../compiler-CPsEzFP2.js";
 var b = (d) => {
   const l = {
     ...{

package/dist/adapters/nextjs/index.d.ts

@@ -21,22 +21,22 @@ export interface NextCorsOptions {
      */
     credentials?: boolean;
 }
-export interface NextAdapterOptions<TSchema extends Record<string, any> = Record<string, any>> {
+export interface NextAdapterOptions {
     /**
      * Array of cube definitions to register
      */
-    cubes: Cube<TSchema>[];
+    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<TSchema> | MySql2Database<TSchema> | BetterSQLite3Database<TSchema> | DrizzleDatabase<TSchema>;
+    drizzle: PostgresJsDatabase<any> | MySql2Database<any> | BetterSQLite3Database<any> | DrizzleDatabase;
     /**
      * Database schema for type inference (RECOMMENDED)
      * Provides full type safety for cube definitions
      */
-    schema?: TSchema;
+    schema?: any;
     /**
      * Extract security context from incoming HTTP request.
      * Called for EVERY API request to determine user permissions and multi-tenant isolation.
@@ -93,19 +93,19 @@ export declare function createOptionsHandler(corsOptions: NextCorsOptions): Rout
 /**
  * Create load handler - Execute queries
  */
-export declare function createLoadHandler<TSchema extends Record<string, any> = Record<string, any>>(options: NextAdapterOptions<TSchema>): RouteHandler;
+export declare function createLoadHandler(options: NextAdapterOptions): RouteHandler;
 /**
  * Create meta handler - Get cube metadata
  */
-export declare function createMetaHandler<TSchema extends Record<string, any> = Record<string, any>>(options: NextAdapterOptions<TSchema>): RouteHandler;
+export declare function createMetaHandler(options: NextAdapterOptions): RouteHandler;
 /**
  * Create SQL handler - Generate SQL without execution
  */
-export declare function createSqlHandler<TSchema extends Record<string, any> = Record<string, any>>(options: NextAdapterOptions<TSchema>): RouteHandler;
+export declare function createSqlHandler(options: NextAdapterOptions): RouteHandler;
 /**
  * Create dry-run handler - Validate queries without execution
  */
-export declare function createDryRunHandler<TSchema extends Record<string, any> = Record<string, any>>(options: NextAdapterOptions<TSchema>): RouteHandler;
+export declare function createDryRunHandler(options: NextAdapterOptions): RouteHandler;
 /**
  * Convenience function to create all route handlers
  *
@@ -125,5 +125,5 @@ export declare function createDryRunHandler<TSchema extends Record<string, any>
  * export const GET = handlers.load
  * export const POST = handlers.load
  */
-export declare function createCubeHandlers<TSchema extends Record<string, any> = Record<string, any>>(options: NextAdapterOptions<TSchema>): CubeHandlers;
+export declare function createCubeHandlers(options: NextAdapterOptions): CubeHandlers;
 export type { SecurityContext, DatabaseExecutor, SemanticQuery, DrizzleDatabase, NextCorsOptions as CorsOptions };

package/dist/adapters/nextjs/index.js

@@ -1,5 +1,5 @@
 import { NextResponse as o } from "next/server";
-import { c as l, f as C, a as H, b as p, h as v, S as A } from "../compiler-Dec55JjO.js";
+import { c as l, f as C, a as H, b as p, h as v, S as A } from "../compiler-CPsEzFP2.js";
 function g(t) {
   const { cubes: e, drizzle: n, schema: s, engineType: y } = t;
   if (!e || e.length === 0)

package/dist/adapters/utils.d.ts

@@ -14,11 +14,11 @@ export declare function buildTransformedQuery(query: SemanticQuery): any;
 /**
  * Get database type from semantic layer
  */
-export declare function getDatabaseType(semanticLayer: SemanticLayerCompiler<any>): string;
+export declare function getDatabaseType(semanticLayer: SemanticLayerCompiler): string;
 /**
  * Helper function to handle dry-run logic for all adapters
  */
-export declare function handleDryRun(query: SemanticQuery, securityContext: SecurityContext, semanticLayer: SemanticLayerCompiler<any>): Promise<{
+export declare function handleDryRun(query: SemanticQuery, securityContext: SecurityContext, semanticLayer: SemanticLayerCompiler): Promise<{
     queryType: string;
     normalizedQueries: {
         cube: string;
@@ -65,7 +65,7 @@ export declare function handleDryRun(query: SemanticQuery, securityContext: Secu
 export declare function formatCubeResponse(query: SemanticQuery, result: {
     data: any[];
     annotation?: any;
-}, semanticLayer: SemanticLayerCompiler<any>): {
+}, semanticLayer: SemanticLayerCompiler): {
     queryType: string;
     results: {
         query: SemanticQuery;