drizzle-cube 0.1.12 → 0.1.14

package/dist/adapters/hono/index.js

@@ -1,316 +1,170 @@
-import { Hono as D } from "hono";
-var S = (q) => {
-  const c = {
+import { Hono as x } from "hono";
+import { S as b, f as p, a as v, b as w, h as C } from "../utils-C3A4JGFs.js";
+var A = (y) => {
+  const l = {
     ...{
       origin: "*",
       allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"],
       allowHeaders: [],
       exposeHeaders: []
     },
-    ...q
-  }, v = /* @__PURE__ */ ((u) => typeof u == "string" ? u === "*" ? () => u : (n) => u === n ? n : null : typeof u == "function" ? u : (n) => u.includes(n) ? n : null)(c.origin), j = ((u) => typeof u == "function" ? u : Array.isArray(u) ? () => u : () => [])(c.allowMethods);
-  return async function(n, m) {
-    var x;
-    function p(h, f) {
-      n.res.headers.set(h, f);
+    ...y
+  }, j = /* @__PURE__ */ ((u) => typeof u == "string" ? u === "*" ? () => u : (n) => u === n ? n : null : typeof u == "function" ? u : (n) => u.includes(n) ? n : null)(l.origin), f = ((u) => typeof u == "function" ? u : Array.isArray(u) ? () => u : () => [])(l.allowMethods);
+  return async function(n, d) {
+    var e;
+    function s(r, t) {
+      n.res.headers.set(r, t);
     }
-    const b = v(n.req.header("origin") || "", n);
-    if (b && p("Access-Control-Allow-Origin", b), c.origin !== "*") {
-      const h = n.req.header("Vary");
-      h ? p("Vary", h) : p("Vary", "Origin");
+    const a = j(n.req.header("origin") || "", n);
+    if (a && s("Access-Control-Allow-Origin", a), l.origin !== "*") {
+      const r = n.req.header("Vary");
+      r ? s("Vary", r) : s("Vary", "Origin");
     }
-    if (c.credentials && p("Access-Control-Allow-Credentials", "true"), (x = c.exposeHeaders) != null && x.length && p("Access-Control-Expose-Headers", c.exposeHeaders.join(",")), n.req.method === "OPTIONS") {
-      c.maxAge != null && p("Access-Control-Max-Age", c.maxAge.toString());
-      const h = j(n.req.header("origin") || "", n);
-      h.length && p("Access-Control-Allow-Methods", h.join(","));
-      let f = c.allowHeaders;
-      if (!(f != null && f.length)) {
-        const e = n.req.header("Access-Control-Request-Headers");
-        e && (f = e.split(/\s*,\s*/));
+    if (l.credentials && s("Access-Control-Allow-Credentials", "true"), (e = l.exposeHeaders) != null && e.length && s("Access-Control-Expose-Headers", l.exposeHeaders.join(",")), n.req.method === "OPTIONS") {
+      l.maxAge != null && s("Access-Control-Max-Age", l.maxAge.toString());
+      const r = f(n.req.header("origin") || "", n);
+      r.length && s("Access-Control-Allow-Methods", r.join(","));
+      let t = l.allowHeaders;
+      if (!(t != null && t.length)) {
+        const o = n.req.header("Access-Control-Request-Headers");
+        o && (t = o.split(/\s*,\s*/));
       }
-      return f != null && f.length && (p("Access-Control-Allow-Headers", f.join(",")), n.res.headers.append("Vary", "Access-Control-Request-Headers")), n.res.headers.delete("Content-Length"), n.res.headers.delete("Content-Type"), new Response(null, {
+      return t != null && t.length && (s("Access-Control-Allow-Headers", t.join(",")), n.res.headers.append("Vary", "Access-Control-Request-Headers")), n.res.headers.delete("Content-Length"), n.res.headers.delete("Content-Type"), new Response(null, {
         headers: n.res.headers,
         status: 204,
         statusText: "No Content"
       });
     }
-    await m();
+    await d();
   };
 };
-function E(q) {
+function S(y) {
   const {
-    semanticLayer: a,
-    drizzle: c,
-    schema: v,
-    getSecurityContext: j,
-    cors: u,
-    basePath: n = "/cubejs-api/v1"
-  } = q, m = new D();
-  u && m.use("/*", S(u)), a.hasExecutor() || a.setDrizzle(c, v), m.post(`${n}/load`, async (e) => {
+    cubes: c,
+    drizzle: l,
+    schema: j,
+    extractSecurityContext: f,
+    engineType: u,
+    cors: n,
+    basePath: d = "/cubejs-api/v1"
+  } = y;
+  if (!c || c.length === 0)
+    throw new Error("At least one cube must be provided in the cubes array");
+  const s = new x();
+  n && s.use("/*", A(n));
+  const a = new b({
+    drizzle: l,
+    schema: j,
+    engineType: u
+  });
+  return c.forEach((e) => {
+    a.registerCube(e);
+  }), console.log(`🚀 Drizzle Cube: Registered ${c.length} cube(s) with ${u || "auto-detected"} engine`), s.post(`${d}/load`, async (e) => {
     try {
-      const r = await e.req.json(), s = r.query || r, t = await j(e), o = a.validateQuery(s);
-      if (!o.isValid)
+      const r = await e.req.json(), t = r.query || r, o = await f(e), i = a.validateQuery(t);
+      if (!i.isValid)
         return e.json({
-          error: `Query validation failed: ${o.errors.join(", ")}`
+          error: `Query validation failed: ${i.errors.join(", ")}`
         }, 400);
-      const i = await a.executeMultiCubeQuery(s, t), l = h(a), y = b(), g = (/* @__PURE__ */ new Date()).toISOString(), Q = x(s);
-      return e.json({
-        queryType: "regularQuery",
-        results: [{
-          query: s,
-          lastRefreshTime: g,
-          usedPreAggregations: {},
-          transformedQuery: Q,
-          requestId: y,
-          annotation: i.annotation,
-          dataSource: "default",
-          dbType: l,
-          extDbType: l,
-          external: !1,
-          slowQuery: !1,
-          data: i.data
-        }],
-        pivotQuery: {
-          ...s,
-          queryType: "regularQuery"
-        },
-        slowQuery: !1
-      });
+      const m = await a.executeMultiCubeQuery(t, o);
+      return e.json(p(t, m, a));
     } catch (r) {
       return console.error("Query execution error:", r), e.json({
         error: r instanceof Error ? r.message : "Query execution failed"
       }, 500);
     }
-  }), m.get(`${n}/load`, async (e) => {
+  }), s.get(`${d}/load`, async (e) => {
     try {
       const r = e.req.query("query");
       if (!r)
         return e.json({
           error: "Query parameter is required"
         }, 400);
-      let s;
+      let t;
       try {
-        s = JSON.parse(r);
+        t = JSON.parse(r);
       } catch {
         return e.json({
           error: "Invalid JSON in query parameter"
         }, 400);
       }
-      const t = await j(e), o = a.validateQuery(s);
-      if (!o.isValid)
+      const o = await f(e), i = a.validateQuery(t);
+      if (!i.isValid)
         return e.json({
-          error: `Query validation failed: ${o.errors.join(", ")}`
+          error: `Query validation failed: ${i.errors.join(", ")}`
         }, 400);
-      const i = await a.executeMultiCubeQuery(s, t), l = h(a), y = b(), g = (/* @__PURE__ */ new Date()).toISOString(), Q = x(s);
-      return e.json({
-        queryType: "regularQuery",
-        results: [{
-          query: s,
-          lastRefreshTime: g,
-          usedPreAggregations: {},
-          transformedQuery: Q,
-          requestId: y,
-          annotation: i.annotation,
-          dataSource: "default",
-          dbType: l,
-          extDbType: l,
-          external: !1,
-          slowQuery: !1,
-          data: i.data
-        }],
-        pivotQuery: {
-          ...s,
-          queryType: "regularQuery"
-        },
-        slowQuery: !1
-      });
+      const m = await a.executeMultiCubeQuery(t, o);
+      return e.json(p(t, m, a));
     } catch (r) {
       return console.error("Query execution error:", r), e.json({
         error: r instanceof Error ? r.message : "Query execution failed"
       }, 500);
     }
-  }), m.get(`${n}/meta`, (e) => {
+  }), s.get(`${d}/meta`, (e) => {
     try {
       const r = a.getMetadata();
-      return e.json({
-        cubes: r
-      });
+      return e.json(v(r));
     } catch (r) {
       return console.error("Metadata error:", r), e.json({
         error: r instanceof Error ? r.message : "Failed to fetch metadata"
       }, 500);
     }
-  }), m.post(`${n}/sql`, async (e) => {
-    var r, s;
+  }), s.post(`${d}/sql`, async (e) => {
+    var r, t;
     try {
-      const t = await e.req.json(), o = await j(e), i = a.validateQuery(t);
-      if (!i.isValid)
+      const o = await e.req.json(), i = await f(e), m = a.validateQuery(o);
+      if (!m.isValid)
         return e.json({
-          error: `Query validation failed: ${i.errors.join(", ")}`
+          error: `Query validation failed: ${m.errors.join(", ")}`
         }, 400);
-      const l = ((r = t.measures) == null ? void 0 : r[0]) || ((s = t.dimensions) == null ? void 0 : s[0]);
-      if (!l)
+      const q = ((r = o.measures) == null ? void 0 : r[0]) || ((t = o.dimensions) == null ? void 0 : t[0]);
+      if (!q)
         return e.json({
           error: "No measures or dimensions specified"
         }, 400);
-      const y = l.split(".")[0], g = await a.generateSQL(y, t, o);
-      return e.json({
-        sql: g.sql,
-        params: g.params || [],
-        query: t
-      });
-    } catch (t) {
-      return console.error("SQL generation error:", t), e.json({
-        error: t instanceof Error ? t.message : "SQL generation failed"
+      const g = q.split(".")[0], h = await a.generateSQL(g, o, i);
+      return e.json(w(o, h));
+    } catch (o) {
+      return console.error("SQL generation error:", o), e.json({
+        error: o instanceof Error ? o.message : "SQL generation failed"
       }, 500);
     }
-  }), m.get(`${n}/sql`, async (e) => {
-    var r, s;
+  }), s.get(`${d}/sql`, async (e) => {
+    var r, t;
     try {
-      const t = e.req.query("query");
-      if (!t)
+      const o = e.req.query("query");
+      if (!o)
         return e.json({
           error: "Query parameter is required"
         }, 400);
-      const o = JSON.parse(t), i = await j(e), l = a.validateQuery(o);
-      if (!l.isValid)
+      const i = JSON.parse(o), m = await f(e), q = a.validateQuery(i);
+      if (!q.isValid)
         return e.json({
-          error: `Query validation failed: ${l.errors.join(", ")}`
+          error: `Query validation failed: ${q.errors.join(", ")}`
         }, 400);
-      const y = ((r = o.measures) == null ? void 0 : r[0]) || ((s = o.dimensions) == null ? void 0 : s[0]);
-      if (!y)
+      const g = ((r = i.measures) == null ? void 0 : r[0]) || ((t = i.dimensions) == null ? void 0 : t[0]);
+      if (!g)
         return e.json({
           error: "No measures or dimensions specified"
         }, 400);
-      const g = y.split(".")[0], Q = await a.generateSQL(g, o, i);
-      return e.json({
-        sql: Q.sql,
-        params: Q.params || [],
-        query: o
-      });
-    } catch (t) {
-      return console.error("SQL generation error:", t), e.json({
-        error: t instanceof Error ? t.message : "SQL generation failed"
+      const h = g.split(".")[0], Q = await a.generateSQL(h, i, m);
+      return e.json(w(i, Q));
+    } catch (o) {
+      return console.error("SQL generation error:", o), e.json({
+        error: o instanceof Error ? o.message : "SQL generation failed"
       }, 500);
     }
-  });
-  function p(e) {
-    var s, t, o, i;
-    let r = 0;
-    return r += (((s = e.measures) == null ? void 0 : s.length) || 0) * 1, r += (((t = e.dimensions) == null ? void 0 : t.length) || 0) * 1, r += (((o = e.filters) == null ? void 0 : o.length) || 0) * 2, r += (((i = e.timeDimensions) == null ? void 0 : i.length) || 0) * 3, r <= 5 ? "low" : r <= 15 ? "medium" : "high";
-  }
-  function b() {
-    const e = Date.now(), r = Math.random().toString(36).substring(2, 9);
-    return `${e}-${r}`;
-  }
-  function x(e) {
-    const r = e.dimensions || [], s = e.timeDimensions || [], t = e.measures || [];
-    return {
-      sortedDimensions: r,
-      sortedTimeDimensions: s,
-      timeDimensions: s,
-      measures: t,
-      leafMeasureAdditive: !0,
-      leafMeasures: t,
-      measureToLeafMeasures: {},
-      hasNoTimeDimensionsWithoutGranularity: !0,
-      allFiltersWithinSelectedDimensions: !0,
-      isAdditive: !0,
-      granularityHierarchies: {},
-      hasMultipliedMeasures: !1,
-      hasCumulativeMeasures: !1,
-      windowGranularity: null,
-      filterDimensionsSingleValueEqual: {},
-      ownedDimensions: r,
-      ownedTimeDimensionsWithRollupGranularity: [],
-      ownedTimeDimensionsAsIs: [],
-      allBackAliasMembers: {},
-      hasMultiStage: !1
-    };
-  }
-  function h(e) {
-    if (e.hasExecutor()) {
-      const r = e.databaseExecutor;
-      if (r != null && r.engineType)
-        return r.engineType;
-    }
-    return "postgres";
-  }
-  async function f(e, r) {
-    var y, g, Q, A;
-    const s = a.validateQuery(e);
-    if (!s.isValid)
-      throw new Error(`Query validation failed: ${s.errors.join(", ")}`);
-    const t = /* @__PURE__ */ new Set();
-    (y = e.measures) == null || y.forEach((d) => {
-      const w = d.split(".")[0];
-      t.add(w);
-    }), (g = e.dimensions) == null || g.forEach((d) => {
-      const w = d.split(".")[0];
-      t.add(w);
-    }), (Q = e.timeDimensions) == null || Q.forEach((d) => {
-      const w = d.dimension.split(".")[0];
-      t.add(w);
-    }), (A = e.filters) == null || A.forEach((d) => {
-      if ("member" in d) {
-        const w = d.member.split(".")[0];
-        t.add(w);
-      }
-    });
-    const o = t.size > 1;
-    let i;
-    if (o)
-      i = await a.generateMultiCubeSQL(e, r);
-    else {
-      const d = Array.from(t)[0];
-      i = await a.generateSQL(d, e, r);
-    }
-    const l = Array.from(t).map((d) => {
-      var w, T;
-      return {
-        cube: d,
-        query: {
-          measures: ((w = e.measures) == null ? void 0 : w.filter((C) => C.startsWith(d + "."))) || [],
-          dimensions: ((T = e.dimensions) == null ? void 0 : T.filter((C) => C.startsWith(d + "."))) || [],
-          filters: e.filters || [],
-          timeDimensions: e.timeDimensions || [],
-          order: e.order || {},
-          limit: e.limit,
-          offset: e.offset
-        }
-      };
-    });
-    return {
-      queryType: "regularQuery",
-      normalizedQueries: l,
-      queryOrder: Array.from(t),
-      transformedQueries: l,
-      pivotQuery: {
-        query: e,
-        cubes: Array.from(t)
-      },
-      sql: {
-        sql: [i.sql],
-        params: i.params || []
-      },
-      complexity: p(e),
-      valid: !0,
-      cubesUsed: Array.from(t),
-      joinType: o ? "multi_cube_join" : "single_cube",
-      query: e
-    };
-  }
-  return m.post(`${n}/dry-run`, async (e) => {
+  }), s.post(`${d}/dry-run`, async (e) => {
     try {
-      const r = await e.req.json(), s = r.query || r, t = await j(e), o = await f(s, t);
-      return e.json(o);
+      const r = await e.req.json(), t = r.query || r, o = await f(e), i = await C(t, o, a);
+      return e.json(i);
     } catch (r) {
       return console.error("Dry-run error:", r), e.json({
         error: r instanceof Error ? r.message : "Dry-run validation failed",
         valid: !1
       }, 400);
     }
-  }), m.get(`${n}/dry-run`, async (e) => {
+  }), s.get(`${d}/dry-run`, async (e) => {
     try {
       const r = e.req.query("query");
       if (!r)
@@ -318,26 +172,26 @@ function E(q) {
           error: "Query parameter is required",
           valid: !1
         }, 400);
-      const s = JSON.parse(r), t = await j(e), o = await f(s, t);
-      return e.json(o);
+      const t = JSON.parse(r), o = await f(e), i = await C(t, o, a);
+      return e.json(i);
     } catch (r) {
       return console.error("Dry-run error:", r), e.json({
         error: r instanceof Error ? r.message : "Dry-run validation failed",
         valid: !1
       }, 400);
     }
-  }), m;
+  }), s;
 }
-function M(q, a) {
-  const c = E(a);
-  return q.route("/", c), q;
+function E(y, c) {
+  const l = S(c);
+  return y.route("/", l), y;
 }
-function N(q) {
-  const a = new D();
-  return M(a, q);
+function $(y) {
+  const c = new x();
+  return E(c, y);
 }
 export {
-  N as createCubeApp,
-  E as createCubeRoutes,
-  M as mountCubeRoutes
+  $ as createCubeApp,
+  S as createCubeRoutes,
+  E as mountCubeRoutes
 };

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

@@ -0,0 +1,129 @@
+import { NextRequest } from 'next/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 NextCorsOptions {
+    /**
+     * Allowed origins for CORS
+     */
+    origin?: string | string[] | ((origin: string) => boolean);
+    /**
+     * Allowed HTTP methods
+     */
+    methods?: string[];
+    /**
+     * Allowed headers
+     */
+    allowedHeaders?: string[];
+    /**
+     * Allow credentials
+     */
+    credentials?: boolean;
+}
+export interface NextAdapterOptions<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 - Next.js Request object containing the incoming HTTP request
+     * @param context - Route context with params (optional)
+     * @returns Security context with organisationId, userId, roles, etc.
+     *
+     * @example
+     * extractSecurityContext: async (request, context) => {
+     *   // Extract JWT from Authorization header
+     *   const token = request.headers.get('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: NextRequest, context?: RouteContext) => SecurityContext | Promise<SecurityContext>;
+    /**
+     * Database engine type (optional - auto-detected if not provided)
+     */
+    engineType?: 'postgres' | 'mysql' | 'sqlite';
+    /**
+     * CORS configuration (optional)
+     */
+    cors?: NextCorsOptions;
+    /**
+     * Runtime environment (default: 'nodejs')
+     * 'edge' for Edge Runtime, 'nodejs' for Node.js Runtime
+     */
+    runtime?: 'edge' | 'nodejs';
+}
+export interface RouteContext {
+    params?: Record<string, string | string[]>;
+}
+export type RouteHandler = (request: NextRequest, context?: RouteContext) => Promise<Response>;
+export interface CubeHandlers {
+    load: RouteHandler;
+    meta: RouteHandler;
+    sql: RouteHandler;
+    dryRun: RouteHandler;
+}
+/**
+ * Create OPTIONS handler for CORS preflight requests
+ */
+export declare function createOptionsHandler(corsOptions: NextCorsOptions): RouteHandler;
+/**
+ * Create load handler - Execute queries
+ */
+export declare function createLoadHandler<TSchema extends Record<string, any> = Record<string, any>>(options: NextAdapterOptions<TSchema>): RouteHandler;
+/**
+ * Create meta handler - Get cube metadata
+ */
+export declare function createMetaHandler<TSchema extends Record<string, any> = Record<string, any>>(options: NextAdapterOptions<TSchema>): RouteHandler;
+/**
+ * Create SQL handler - Generate SQL without execution
+ */
+export declare function createSqlHandler<TSchema extends Record<string, any> = Record<string, any>>(options: NextAdapterOptions<TSchema>): 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;
+/**
+ * Convenience function to create all route handlers
+ *
+ * @example
+ * const handlers = createCubeHandlers({
+ *   cubes: [salesCube, employeesCube],
+ *   drizzle: db,
+ *   schema,
+ *   extractSecurityContext: async (request, context) => {
+ *     const token = request.headers.get('Authorization')?.replace('Bearer ', '')
+ *     const decoded = await verifyJWT(token)
+ *     return { organisationId: decoded.orgId, userId: decoded.userId }
+ *   }
+ * })
+ *
+ * // Use in your API routes:
+ * 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 type { SecurityContext, DatabaseExecutor, SemanticQuery, DrizzleDatabase, NextCorsOptions as CorsOptions };