drizzle-cube 0.1.11 → 0.1.13

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

@@ -0,0 +1,89 @@
+import { Router, Request, Response, Express } from 'express';
+import { CorsOptions } from 'cors';
+import { SemanticQuery, SecurityContext, DatabaseExecutor, DrizzleDatabase, Cube } from '../../server';
+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>> {
+    /**
+     * Array of cube definitions to register
+     */
+    cubes: Cube<TSchema>[];
+    /**
+     * 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>;
+    /**
+     * Database schema for type inference (RECOMMENDED)
+     * Provides full type safety for cube definitions
+     */
+    schema?: TSchema;
+    /**
+     * 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';
+    /**
+     * CORS configuration (optional)
+     */
+    cors?: CorsOptions;
+    /**
+     * API base path (default: '/cubejs-api/v1')
+     */
+    basePath?: string;
+    /**
+     * JSON body parser limit (default: '10mb')
+     */
+    jsonLimit?: string;
+}
+/**
+ * Create Express router for Cube.js-compatible API
+ */
+export declare function createCubeRouter<TSchema extends Record<string, any> = Record<string, any>>(options: ExpressAdapterOptions<TSchema>): 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;
+/**
+ * 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<TSchema extends Record<string, any> = Record<string, any>>(options: ExpressAdapterOptions<TSchema>): Express;
+export type { SecurityContext, DatabaseExecutor, SemanticQuery, DrizzleDatabase, CorsOptions };

package/dist/adapters/express/index.js

@@ -0,0 +1,177 @@
+import g, { Router as $ } from "express";
+import E from "cors";
+import { S as R, c as a, f as v, a as L, b as x, h as C } from "../utils-C3A4JGFs.js";
+function N(y) {
+  const {
+    cubes: c,
+    drizzle: p,
+    schema: w,
+    extractSecurityContext: d,
+    engineType: Q,
+    cors: h,
+    basePath: l = "/cubejs-api/v1",
+    jsonLimit: q = "10mb"
+  } = y;
+  if (!c || c.length === 0)
+    throw new Error("At least one cube must be provided in the cubes array");
+  const u = $();
+  h && u.use(E(h)), u.use(g.json({ limit: q })), u.use(g.urlencoded({ extended: !0, limit: q }));
+  const n = new R({
+    drizzle: p,
+    schema: w,
+    engineType: Q
+  });
+  return c.forEach((t) => {
+    n.registerCube(t);
+  }), console.log(`🚀 Drizzle Cube: Registered ${c.length} cube(s) with ${Q || "auto-detected"} engine`), u.post(`${l}/load`, async (t, r) => {
+    try {
+      const e = t.body.query || t.body, s = await d(t, r), o = n.validateQuery(e);
+      if (!o.isValid)
+        return r.status(400).json(a(
+          `Query validation failed: ${o.errors.join(", ")}`,
+          400
+        ));
+      const i = await n.executeMultiCubeQuery(e, s);
+      r.json(v(e, i, n));
+    } catch (e) {
+      console.error("Query execution error:", e), r.status(500).json(a(
+        e instanceof Error ? e.message : "Query execution failed",
+        500
+      ));
+    }
+  }), u.get(`${l}/load`, async (t, r) => {
+    try {
+      const e = t.query.query;
+      if (!e)
+        return r.status(400).json(a(
+          "Query parameter is required",
+          400
+        ));
+      let s;
+      try {
+        s = JSON.parse(e);
+      } catch {
+        return r.status(400).json(a(
+          "Invalid JSON in query parameter",
+          400
+        ));
+      }
+      const o = await d(t, r), i = n.validateQuery(s);
+      if (!i.isValid)
+        return r.status(400).json(a(
+          `Query validation failed: ${i.errors.join(", ")}`,
+          400
+        ));
+      const f = await n.executeMultiCubeQuery(s, o);
+      r.json(v(s, f, n));
+    } catch (e) {
+      console.error("Query execution error:", e), r.status(500).json(a(
+        e instanceof Error ? e.message : "Query execution failed",
+        500
+      ));
+    }
+  }), u.get(`${l}/meta`, (t, r) => {
+    try {
+      const e = n.getMetadata();
+      r.json(L(e));
+    } catch (e) {
+      console.error("Metadata error:", e), r.status(500).json(a(
+        e instanceof Error ? e.message : "Failed to fetch metadata",
+        500
+      ));
+    }
+  }), u.post(`${l}/sql`, async (t, r) => {
+    var e, s;
+    try {
+      const o = t.body, i = await d(t, r), f = n.validateQuery(o);
+      if (!f.isValid)
+        return r.status(400).json(a(
+          `Query validation failed: ${f.errors.join(", ")}`,
+          400
+        ));
+      const m = ((e = o.measures) == null ? void 0 : e[0]) || ((s = o.dimensions) == null ? void 0 : s[0]);
+      if (!m)
+        return r.status(400).json(a(
+          "No measures or dimensions specified",
+          400
+        ));
+      const j = m.split(".")[0], b = await n.generateSQL(j, o, i);
+      r.json(x(o, b));
+    } catch (o) {
+      console.error("SQL generation error:", o), r.status(500).json(a(
+        o instanceof Error ? o.message : "SQL generation failed",
+        500
+      ));
+    }
+  }), u.get(`${l}/sql`, async (t, r) => {
+    var e, s;
+    try {
+      const o = t.query.query;
+      if (!o)
+        return r.status(400).json(a(
+          "Query parameter is required",
+          400
+        ));
+      const i = JSON.parse(o), f = await d(t, r), m = n.validateQuery(i);
+      if (!m.isValid)
+        return r.status(400).json(a(
+          `Query validation failed: ${m.errors.join(", ")}`,
+          400
+        ));
+      const j = ((e = i.measures) == null ? void 0 : e[0]) || ((s = i.dimensions) == null ? void 0 : s[0]);
+      if (!j)
+        return r.status(400).json(a(
+          "No measures or dimensions specified",
+          400
+        ));
+      const b = j.split(".")[0], S = await n.generateSQL(b, i, f);
+      r.json(x(i, S));
+    } catch (o) {
+      console.error("SQL generation error:", o), r.status(500).json(a(
+        o instanceof Error ? o.message : "SQL generation failed",
+        500
+      ));
+    }
+  }), u.post(`${l}/dry-run`, async (t, r) => {
+    try {
+      const e = t.body.query || t.body, s = await d(t, r), o = await C(e, s, n);
+      r.json(o);
+    } catch (e) {
+      console.error("Dry-run error:", e), r.status(400).json({
+        error: e instanceof Error ? e.message : "Dry-run validation failed",
+        valid: !1
+      });
+    }
+  }), u.get(`${l}/dry-run`, async (t, r) => {
+    try {
+      const e = t.query.query;
+      if (!e)
+        return r.status(400).json({
+          error: "Query parameter is required",
+          valid: !1
+        });
+      const s = JSON.parse(e), o = await d(t, r), i = await C(s, o, n);
+      r.json(i);
+    } catch (e) {
+      console.error("Dry-run error:", e), r.status(400).json({
+        error: e instanceof Error ? e.message : "Dry-run validation failed",
+        valid: !1
+      });
+    }
+  }), u.use((t, r, e, s) => {
+    console.error("Express adapter error:", t), e.headersSent || e.status(500).json(a(t, 500));
+  }), u;
+}
+function M(y, c) {
+  const p = N(c);
+  return y.use("/", p), y;
+}
+function O(y) {
+  const c = g();
+  return M(c, y);
+}
+export {
+  O as createCubeApp,
+  N as createCubeRouter,
+  M as mountCubeRoutes
+};

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

@@ -0,0 +1,88 @@
+import { FastifyPluginCallback, FastifyRequest, FastifyInstance } from 'fastify';
+import { FastifyCorsOptions } from '@fastify/cors';
+import { SemanticQuery, SecurityContext, DatabaseExecutor, DrizzleDatabase, Cube } from '../../server';
+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>> {
+    /**
+     * Array of cube definitions to register
+     */
+    cubes: Cube<TSchema>[];
+    /**
+     * 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>;
+    /**
+     * Database schema for type inference (RECOMMENDED)
+     * Provides full type safety for cube definitions
+     */
+    schema?: TSchema;
+    /**
+     * 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';
+    /**
+     * CORS configuration (optional)
+     */
+    cors?: FastifyCorsOptions;
+    /**
+     * API base path (default: '/cubejs-api/v1')
+     */
+    basePath?: string;
+    /**
+     * JSON body parser limit (default: 10485760 - 10MB)
+     */
+    bodyLimit?: number;
+}
+/**
+ * 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<TSchema extends Record<string, any> = Record<string, any>>(fastify: FastifyInstance, options: FastifyAdapterOptions<TSchema>): 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<TSchema extends Record<string, any> = Record<string, any>>(options: FastifyAdapterOptions<TSchema>): FastifyInstance;
+export type { SecurityContext, DatabaseExecutor, SemanticQuery, DrizzleDatabase, FastifyCorsOptions };

package/dist/adapters/fastify/index.js

@@ -0,0 +1,213 @@
+import { S as P, c as u, f as Q, a as R, b as C, h as w } from "../utils-C3A4JGFs.js";
+const x = function(o, S, h) {
+  const {
+    cubes: m,
+    drizzle: $,
+    schema: E,
+    extractSecurityContext: y,
+    engineType: q,
+    cors: v,
+    basePath: d = "/cubejs-api/v1",
+    bodyLimit: p = 10485760
+    // 10MB
+  } = S;
+  if (!m || m.length === 0)
+    return h(new Error("At least one cube must be provided in the cubes array"));
+  v && o.register(import("@fastify/cors"), v), o.addHook("onRequest", async (r, t) => {
+    r.method === "POST" && (r.body = void 0);
+  });
+  const i = new P({
+    drizzle: $,
+    schema: E,
+    engineType: q
+  });
+  m.forEach((r) => {
+    i.registerCube(r);
+  }), console.log(`🚀 Drizzle Cube: Registered ${m.length} cube(s) with ${q || "auto-detected"} engine`), o.post(`${d}/load`, {
+    bodyLimit: p,
+    schema: {
+      body: {
+        type: "object",
+        additionalProperties: !0
+      }
+    }
+  }, async (r, t) => {
+    try {
+      const e = r.body, a = e.query || e, s = await y(r), n = i.validateQuery(a);
+      if (!n.isValid)
+        return t.status(400).send(u(
+          `Query validation failed: ${n.errors.join(", ")}`,
+          400
+        ));
+      const c = await i.executeMultiCubeQuery(a, s);
+      return Q(a, c, i);
+    } catch (e) {
+      return r.log.error(e, "Query execution error"), t.status(500).send(u(
+        e instanceof Error ? e.message : "Query execution failed",
+        500
+      ));
+    }
+  }), o.get(`${d}/load`, {
+    schema: {
+      querystring: {
+        type: "object",
+        properties: {
+          query: { type: "string" }
+        },
+        required: ["query"]
+      }
+    }
+  }, async (r, t) => {
+    try {
+      const { query: e } = r.query;
+      let a;
+      try {
+        a = JSON.parse(e);
+      } catch {
+        return t.status(400).send(u(
+          "Invalid JSON in query parameter",
+          400
+        ));
+      }
+      const s = await y(r), n = i.validateQuery(a);
+      if (!n.isValid)
+        return t.status(400).send(u(
+          `Query validation failed: ${n.errors.join(", ")}`,
+          400
+        ));
+      const c = await i.executeMultiCubeQuery(a, s);
+      return Q(a, c, i);
+    } catch (e) {
+      return r.log.error(e, "Query execution error"), t.status(500).send(u(
+        e instanceof Error ? e.message : "Query execution failed",
+        500
+      ));
+    }
+  }), o.get(`${d}/meta`, async (r, t) => {
+    try {
+      const e = i.getMetadata();
+      return R(e);
+    } catch (e) {
+      return r.log.error(e, "Metadata error"), t.status(500).send(u(
+        e instanceof Error ? e.message : "Failed to fetch metadata",
+        500
+      ));
+    }
+  }), o.post(`${d}/sql`, {
+    bodyLimit: p,
+    schema: {
+      body: {
+        type: "object",
+        additionalProperties: !0
+      }
+    }
+  }, async (r, t) => {
+    var e, a;
+    try {
+      const s = r.body, n = await y(r), c = i.validateQuery(s);
+      if (!c.isValid)
+        return t.status(400).send(u(
+          `Query validation failed: ${c.errors.join(", ")}`,
+          400
+        ));
+      const l = ((e = s.measures) == null ? void 0 : e[0]) || ((a = s.dimensions) == null ? void 0 : a[0]);
+      if (!l)
+        return t.status(400).send(u(
+          "No measures or dimensions specified",
+          400
+        ));
+      const b = l.split(".")[0], f = await i.generateSQL(b, s, n);
+      return C(s, f);
+    } catch (s) {
+      return r.log.error(s, "SQL generation error"), t.status(500).send(u(
+        s instanceof Error ? s.message : "SQL generation failed",
+        500
+      ));
+    }
+  }), o.get(`${d}/sql`, {
+    schema: {
+      querystring: {
+        type: "object",
+        properties: {
+          query: { type: "string" }
+        },
+        required: ["query"]
+      }
+    }
+  }, async (r, t) => {
+    var e, a;
+    try {
+      const { query: s } = r.query, n = JSON.parse(s), c = await y(r), l = i.validateQuery(n);
+      if (!l.isValid)
+        return t.status(400).send(u(
+          `Query validation failed: ${l.errors.join(", ")}`,
+          400
+        ));
+      const b = ((e = n.measures) == null ? void 0 : e[0]) || ((a = n.dimensions) == null ? void 0 : a[0]);
+      if (!b)
+        return t.status(400).send(u(
+          "No measures or dimensions specified",
+          400
+        ));
+      const f = b.split(".")[0], j = await i.generateSQL(f, n, c);
+      return C(n, j);
+    } catch (s) {
+      return r.log.error(s, "SQL generation error"), t.status(500).send(u(
+        s instanceof Error ? s.message : "SQL generation failed",
+        500
+      ));
+    }
+  }), o.post(`${d}/dry-run`, {
+    bodyLimit: p,
+    schema: {
+      body: {
+        type: "object",
+        additionalProperties: !0
+      }
+    }
+  }, async (r, t) => {
+    try {
+      const e = r.body, a = e.query || e, s = await y(r);
+      return await w(a, s, i);
+    } catch (e) {
+      return r.log.error(e, "Dry-run error"), t.status(400).send({
+        error: e instanceof Error ? e.message : "Dry-run validation failed",
+        valid: !1
+      });
+    }
+  }), o.get(`${d}/dry-run`, {
+    schema: {
+      querystring: {
+        type: "object",
+        properties: {
+          query: { type: "string" }
+        },
+        required: ["query"]
+      }
+    }
+  }, async (r, t) => {
+    try {
+      const { query: e } = r.query, a = JSON.parse(e), s = await y(r);
+      return await w(a, s, i);
+    } catch (e) {
+      return r.log.error(e, "Dry-run error"), t.status(400).send({
+        error: e instanceof Error ? e.message : "Dry-run validation failed",
+        valid: !1
+      });
+    }
+  }), o.setErrorHandler(async (r, t, e) => (t.log.error(r, "Fastify cube adapter error"), e.statusCode < 400 && e.status(500), u(r, e.statusCode))), h();
+};
+async function N(g, o) {
+  await g.register(x, o);
+}
+function M(g) {
+  const o = require("fastify")({
+    logger: !0
+  });
+  return o.register(x, g), o;
+}
+export {
+  M as createCubeApp,
+  x as cubePlugin,
+  N as registerCubeRoutes
+};

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

@@ -1,13 +1,13 @@
 import { Hono } from 'hono';
-import { SemanticLayerCompiler, SemanticQuery, SecurityContext, DatabaseExecutor, DrizzleDatabase } from '../../server';
+import { SemanticQuery, SecurityContext, DatabaseExecutor, DrizzleDatabase, Cube } from '../../server';
 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>> {
     /**
-     * The semantic layer instance to use
+     * Array of cube definitions to register
      */
-    semanticLayer: SemanticLayerCompiler<TSchema>;
+    cubes: Cube<TSchema>[];
     /**
      * Drizzle database instance (REQUIRED)
      * This is the core of drizzle-cube - Drizzle ORM integration
@@ -20,10 +20,33 @@ export interface HonoAdapterOptions<TSchema extends Record<string, any> = Record
      */
     schema?: TSchema;
     /**
-     * Function to extract security context from Hono context
-     * This is where you provide your app-specific context extraction logic
+     * 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
+     *   }
+     * }
      */
-    getSecurityContext: (c: any) => SecurityContext | Promise<SecurityContext>;
+    extractSecurityContext: (c: any) => SecurityContext | Promise<SecurityContext>;
+    /**
+     * Database engine type (optional - auto-detected if not provided)
+     */
+    engineType?: 'postgres' | 'mysql' | 'sqlite';
     /**
      * CORS configuration (optional)
      */
@@ -48,6 +71,18 @@ export declare function createCubeRoutes<TSchema extends Record<string, any> = R
 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, "/">;
 /**
  * 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<TSchema extends Record<string, any> = Record<string, any>>(options: HonoAdapterOptions<TSchema>): Hono<import('hono/types').BlankEnv, import('hono/types').BlankSchema, "/">;
 export type { SecurityContext, DatabaseExecutor, SemanticQuery, DrizzleDatabase };