drizzle-cube 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Drizzle Cube
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/adapters/hono/index.js

@@ -0,0 +1,5 @@
+function o() {
+}
+export {
+  o as createHonoRoutes
+};

package/dist/client/index.js

@@ -0,0 +1,7 @@
+import { jsx as i } from "react/jsx-runtime";
+function e() {
+  return /* @__PURE__ */ i("div", { children: "Analytics Page - Coming in Phase 4" });
+}
+export {
+  e as AnalyticsPage
+};

package/dist/server/index.d.ts

@@ -0,0 +1,495 @@
+export declare interface CompiledCube extends SemanticCube {
+    queryFn: (query: SemanticQuery, context: SecurityContext) => Promise<QueryResult>;
+}
+
+/**
+ * Create a new semantic layer instance
+ * Use this when you need multiple isolated instances
+ */
+export declare function createSemanticLayer(dbExecutor?: DatabaseExecutor): SemanticLayerCompiler;
+
+export declare interface CubeMetadata {
+    name: string;
+    title: string;
+    description?: string;
+    measures: MeasureMetadata[];
+    dimensions: DimensionMetadata[];
+    segments: any[];
+}
+
+export declare interface DatabaseExecutor {
+    execute(sql: string, params?: any[]): Promise<any[]>;
+}
+
+/**
+ * Main semantic layer instance
+ * Use this for simple single-instance usage
+ */
+export declare const defaultSemanticLayer: SemanticLayerCompiler;
+
+export declare const departmentsCube: SemanticCube;
+
+export declare interface DimensionAnnotation {
+    title: string;
+    shortTitle: string;
+    type: string;
+    format?: DimensionFormat;
+}
+
+export declare type DimensionFormat = 'currency' | 'percent' | 'number' | 'date' | 'datetime';
+
+export declare interface DimensionMetadata {
+    name: string;
+    title: string;
+    shortTitle: string;
+    type: string;
+    format?: DimensionFormat;
+    description?: string;
+}
+
+export declare const employeeDepartmentsCube: SemanticCube;
+
+/**
+ * Example cube definitions for documentation and testing
+ * These show the basic patterns for defining cubes
+ */
+export declare const employeesCube: SemanticCube;
+
+export declare const exampleCubes: SemanticCube[];
+
+export declare type FilterOperator = 'equals' | 'notEquals' | 'contains' | 'notContains' | 'startsWith' | 'notStartsWith' | 'endsWith' | 'notEndsWith' | 'gt' | 'gte' | 'lt' | 'lte' | 'set' | 'notSet' | 'inDateRange' | 'beforeDate' | 'afterDate';
+
+export declare interface MeasureAnnotation {
+    title: string;
+    shortTitle: string;
+    type: MeasureType;
+    format?: MeasureFormat;
+}
+
+export declare type MeasureFormat = 'currency' | 'percent' | 'number' | 'integer';
+
+export declare interface MeasureMetadata {
+    name: string;
+    title: string;
+    shortTitle: string;
+    type: MeasureType;
+    format?: MeasureFormat;
+    description?: string;
+}
+
+export declare type MeasureType = 'count' | 'countDistinct' | 'countDistinctApprox' | 'sum' | 'avg' | 'min' | 'max' | 'runningTotal' | 'number';
+
+export declare interface QueryContext {
+    securityContext: SecurityContext;
+    cube: CompiledCube;
+    query: SemanticQuery;
+    table: {
+        [column: string]: string;
+    };
+}
+
+export declare interface QueryResult {
+    data: any[];
+    annotation: {
+        measures: Record<string, MeasureAnnotation>;
+        dimensions: Record<string, DimensionAnnotation>;
+        segments: Record<string, any>;
+        timeDimensions: Record<string, TimeDimensionAnnotation>;
+    };
+}
+
+/**
+ * Core types for Drizzle Cube semantic layer
+ * Framework-agnostic definitions
+ */
+export declare interface SecurityContext {
+    [key: string]: any;
+}
+
+export declare interface SemanticCube {
+    name: string;
+    title?: string;
+    description?: string;
+    sql: string | ((context: QueryContext) => SQL | string);
+    dimensions: Record<string, SemanticDimension>;
+    measures: Record<string, SemanticMeasure>;
+    joins?: Record<string, SemanticJoin>;
+    public?: boolean;
+}
+
+export declare interface SemanticDimension {
+    name: string;
+    title?: string;
+    description?: string;
+    type: 'string' | 'number' | 'time' | 'boolean';
+    sql: string | ((context: QueryContext) => SQL | string);
+    primaryKey?: boolean;
+    shown?: boolean;
+    format?: DimensionFormat;
+    meta?: Record<string, any>;
+}
+
+export declare interface SemanticJoin {
+    sql: string;
+    relationship: 'belongsTo' | 'hasOne' | 'hasMany';
+}
+
+export declare const semanticLayer: SemanticLayerCompiler;
+
+export declare class SemanticLayerCompiler {
+    private cubes;
+    private dbExecutor?;
+    constructor(dbExecutor?: DatabaseExecutor);
+    setDatabaseExecutor(executor: DatabaseExecutor): void;
+    registerCube(cube: SemanticCube): void;
+    getCube(name: string): CompiledCube | undefined;
+    getAllCubes(): CompiledCube[];
+    getMetadata(): CubeMetadata[];
+    private validateCube;
+    private compileCube;
+    private generateCubeMetadata;
+}
+
+/**
+ * Utility functions for working with the semantic layer
+ */
+export declare const SemanticLayerUtils: {
+    /**
+     * Create a simple query builder
+     */
+    query: (_cubeName: string) => {
+        measures: (measures: string[]) => {
+            dimensions: (dimensions?: string[]) => {
+                filters: (filters?: any[]) => {
+                    timeDimensions: (timeDimensions?: any[]) => {
+                        limit: (limit?: number) => {
+                            order: (order?: Record<string, "asc" | "desc">) => {
+                                measures: string[];
+                                dimensions: string[];
+                                filters: any[];
+                                timeDimensions: any[];
+                                limit: number | undefined;
+                                order: Record<string, "asc" | "desc"> | undefined;
+                            };
+                        };
+                        order: (order?: Record<string, "asc" | "desc">) => {
+                            measures: string[];
+                            dimensions: string[];
+                            filters: any[];
+                            timeDimensions: any[];
+                            limit: number | undefined;
+                            order: Record<string, "asc" | "desc"> | undefined;
+                        };
+                    };
+                    limit: (limit?: number) => {
+                        order: (order?: Record<string, "asc" | "desc">) => {
+                            measures: string[];
+                            dimensions: string[];
+                            filters: any[];
+                            timeDimensions: any[];
+                            limit: number | undefined;
+                            order: Record<string, "asc" | "desc"> | undefined;
+                        };
+                    };
+                    order: (order?: Record<string, "asc" | "desc">) => {
+                        measures: string[];
+                        dimensions: string[];
+                        filters: any[];
+                        timeDimensions: any[];
+                        limit: number | undefined;
+                        order: Record<string, "asc" | "desc"> | undefined;
+                    };
+                };
+                timeDimensions: (timeDimensions?: any[]) => {
+                    filters: (filters?: any[]) => {
+                        limit: (limit?: number) => {
+                            order: (order?: Record<string, "asc" | "desc">) => {
+                                measures: string[];
+                                dimensions: string[];
+                                filters: any[];
+                                timeDimensions: any[];
+                                limit: number | undefined;
+                                order: Record<string, "asc" | "desc"> | undefined;
+                            };
+                        };
+                        order: (order?: Record<string, "asc" | "desc">) => {
+                            measures: string[];
+                            dimensions: string[];
+                            filters: any[];
+                            timeDimensions: any[];
+                            limit: number | undefined;
+                            order: Record<string, "asc" | "desc"> | undefined;
+                        };
+                    };
+                    limit: (limit?: number) => {
+                        order: (order?: Record<string, "asc" | "desc">) => {
+                            measures: string[];
+                            dimensions: string[];
+                            filters: any[];
+                            timeDimensions: any[];
+                            limit: number | undefined;
+                            order: Record<string, "asc" | "desc"> | undefined;
+                        };
+                    };
+                    order: (order?: Record<string, "asc" | "desc">) => {
+                        measures: string[];
+                        dimensions: string[];
+                        filters: any[];
+                        timeDimensions: any[];
+                        limit: number | undefined;
+                        order: Record<string, "asc" | "desc"> | undefined;
+                    };
+                };
+                limit: (limit?: number) => {
+                    order: (order?: Record<string, "asc" | "desc">) => {
+                        measures: string[];
+                        dimensions: string[];
+                        filters: any[];
+                        timeDimensions: any[];
+                        limit: number | undefined;
+                        order: Record<string, "asc" | "desc"> | undefined;
+                    };
+                };
+                order: (order?: Record<string, "asc" | "desc">) => {
+                    measures: string[];
+                    dimensions: string[];
+                    filters: any[];
+                    timeDimensions: any[];
+                    limit: number | undefined;
+                    order: Record<string, "asc" | "desc"> | undefined;
+                };
+            };
+            filters: (filters?: any[]) => {
+                dimensions: (dimensions?: string[]) => {
+                    timeDimensions: (timeDimensions?: any[]) => {
+                        limit: (limit?: number) => {
+                            order: (order?: Record<string, "asc" | "desc">) => {
+                                measures: string[];
+                                dimensions: string[];
+                                filters: any[];
+                                timeDimensions: any[];
+                                limit: number | undefined;
+                                order: Record<string, "asc" | "desc"> | undefined;
+                            };
+                        };
+                        order: (order?: Record<string, "asc" | "desc">) => {
+                            measures: string[];
+                            dimensions: string[];
+                            filters: any[];
+                            timeDimensions: any[];
+                            limit: number | undefined;
+                            order: Record<string, "asc" | "desc"> | undefined;
+                        };
+                    };
+                    limit: (limit?: number) => {
+                        order: (order?: Record<string, "asc" | "desc">) => {
+                            measures: string[];
+                            dimensions: string[];
+                            filters: any[];
+                            timeDimensions: any[];
+                            limit: number | undefined;
+                            order: Record<string, "asc" | "desc"> | undefined;
+                        };
+                    };
+                    order: (order?: Record<string, "asc" | "desc">) => {
+                        measures: string[];
+                        dimensions: string[];
+                        filters: any[];
+                        timeDimensions: any[];
+                        limit: number | undefined;
+                        order: Record<string, "asc" | "desc"> | undefined;
+                    };
+                };
+                timeDimensions: (timeDimensions?: any[]) => {
+                    dimensions: (dimensions?: string[]) => {
+                        limit: (limit?: number) => {
+                            order: (order?: Record<string, "asc" | "desc">) => {
+                                measures: string[];
+                                dimensions: string[];
+                                filters: any[];
+                                timeDimensions: any[];
+                                limit: number | undefined;
+                                order: Record<string, "asc" | "desc"> | undefined;
+                            };
+                        };
+                        order: (order?: Record<string, "asc" | "desc">) => {
+                            measures: string[];
+                            dimensions: string[];
+                            filters: any[];
+                            timeDimensions: any[];
+                            limit: number | undefined;
+                            order: Record<string, "asc" | "desc"> | undefined;
+                        };
+                    };
+                    limit: (limit?: number) => {
+                        order: (order?: Record<string, "asc" | "desc">) => {
+                            measures: string[];
+                            dimensions: string[];
+                            filters: any[];
+                            timeDimensions: any[];
+                            limit: number | undefined;
+                            order: Record<string, "asc" | "desc"> | undefined;
+                        };
+                    };
+                    order: (order?: Record<string, "asc" | "desc">) => {
+                        measures: string[];
+                        dimensions: string[];
+                        filters: any[];
+                        timeDimensions: any[];
+                        limit: number | undefined;
+                        order: Record<string, "asc" | "desc"> | undefined;
+                    };
+                };
+                limit: (limit?: number) => {
+                    order: (order?: Record<string, "asc" | "desc">) => {
+                        measures: string[];
+                        dimensions: string[];
+                        filters: any[];
+                        timeDimensions: any[];
+                        limit: number | undefined;
+                        order: Record<string, "asc" | "desc"> | undefined;
+                    };
+                };
+                order: (order?: Record<string, "asc" | "desc">) => {
+                    measures: string[];
+                    dimensions: string[];
+                    filters: any[];
+                    timeDimensions: any[];
+                    limit: number | undefined;
+                    order: Record<string, "asc" | "desc"> | undefined;
+                };
+            };
+        };
+    };
+    /**
+     * Create filters
+     */
+    filters: {
+        equals: (member: string, value: any) => {
+            member: string;
+            operator: "equals";
+            values: any[];
+        };
+        notEquals: (member: string, value: any) => {
+            member: string;
+            operator: "notEquals";
+            values: any[];
+        };
+        contains: (member: string, value: string) => {
+            member: string;
+            operator: "contains";
+            values: string[];
+        };
+        greaterThan: (member: string, value: any) => {
+            member: string;
+            operator: "gt";
+            values: any[];
+        };
+        lessThan: (member: string, value: any) => {
+            member: string;
+            operator: "lt";
+            values: any[];
+        };
+        inDateRange: (member: string, from: string, to: string) => {
+            member: string;
+            operator: "inDateRange";
+            values: string[];
+        };
+        set: (member: string) => {
+            member: string;
+            operator: "set";
+            values: never[];
+        };
+        notSet: (member: string) => {
+            member: string;
+            operator: "notSet";
+            values: never[];
+        };
+    };
+    /**
+     * Create time dimensions
+     */
+    timeDimensions: {
+        create: (dimension: string, granularity?: TimeGranularity, dateRange?: string | string[]) => {
+            dimension: string;
+            granularity: TimeGranularity | undefined;
+            dateRange: string | string[] | undefined;
+        };
+    };
+};
+
+export declare interface SemanticMeasure {
+    name: string;
+    title?: string;
+    description?: string;
+    type: MeasureType;
+    sql: string | ((context: QueryContext) => SQL | string);
+    format?: MeasureFormat;
+    filters?: Array<{
+        sql: string;
+    }>;
+    rollingWindow?: {
+        trailing?: string;
+        leading?: string;
+        offset?: string;
+    };
+    meta?: Record<string, any>;
+}
+
+export declare interface SemanticQuery {
+    measures?: string[];
+    dimensions?: string[];
+    filters?: Array<{
+        member: string;
+        operator: FilterOperator;
+        values: any[];
+    }>;
+    timeDimensions?: Array<{
+        dimension: string;
+        granularity?: TimeGranularity;
+        dateRange?: string | string[];
+    }>;
+    limit?: number;
+    offset?: number;
+    order?: Record<string, 'asc' | 'desc'>;
+}
+
+export declare class SemanticQueryExecutor {
+    private dbExecutor;
+    constructor(dbExecutor: DatabaseExecutor);
+    executeQuery(cube: SemanticCube, query: SemanticQuery, securityContext: SecurityContext): Promise<QueryResult>;
+    generateSQL(cube: SemanticCube, query: SemanticQuery, securityContext: SecurityContext): {
+        sql: string;
+        params?: any[];
+    };
+    private substituteSecurityVariables;
+    private buildSelectClause;
+    private buildMeasureSQL;
+    private buildWhereClause;
+    private buildFilterCondition;
+    private buildGroupByClause;
+    private buildOrderByClause;
+    private buildLimitClause;
+    private generateAnnotations;
+}
+
+export declare interface SQL {
+    sql: string;
+    params?: any[];
+}
+
+export declare interface SqlResult {
+    sql: string;
+    params?: any[];
+}
+
+export declare interface TimeDimensionAnnotation {
+    title: string;
+    shortTitle: string;
+    type: string;
+    granularity?: TimeGranularity;
+}
+
+export declare type TimeGranularity = 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year';
+
+export { }

package/dist/server/index.js

@@ -0,0 +1,624 @@
+var u = Object.defineProperty;
+var y = (l, e, n) => e in l ? u(l, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : l[e] = n;
+var c = (l, e, n) => y(l, typeof e != "symbol" ? e + "" : e, n);
+class f {
+  constructor(e) {
+    this.dbExecutor = e;
+  }
+  async executeQuery(e, n, i) {
+    try {
+      const t = this.generateSQL(e, n, i), s = await this.dbExecutor.execute(t.sql, t.params), a = this.generateAnnotations(e, n);
+      return {
+        data: s,
+        annotation: a
+      };
+    } catch (t) {
+      throw new Error(`Query execution failed: ${t instanceof Error ? t.message : "Unknown error"}`);
+    }
+  }
+  generateSQL(e, n, i) {
+    const t = this.substituteSecurityVariables(
+      typeof e.sql == "string" ? e.sql : e.sql.toString(),
+      i
+    ), s = this.buildSelectClause(e, n), a = this.buildWhereClause(e, n), r = this.buildGroupByClause(e, n), o = this.buildOrderByClause(n), m = this.buildLimitClause(n), p = [
+      `SELECT ${s.join(", ")}`,
+      `FROM (${t}) as base_query`
+    ];
+    return a && p.push(`WHERE ${a}`), r && p.push(`GROUP BY ${r}`), o && p.push(`ORDER BY ${o}`), m && p.push(m), { sql: p.join(" "), params: [] };
+  }
+  substituteSecurityVariables(e, n) {
+    let i = e;
+    return Object.entries(n).forEach(([t, s]) => {
+      const a = `\${SECURITY_CONTEXT.${t}}`;
+      i = i.replaceAll(a, `'${s}'`);
+    }), i;
+  }
+  buildSelectClause(e, n) {
+    const i = [];
+    if (n.measures)
+      for (const t of n.measures) {
+        const [s, a] = t.split(".");
+        if (s === e.name && e.measures[a]) {
+          const r = e.measures[a], o = this.buildMeasureSQL(r, a);
+          i.push(`${o} as "${t}"`);
+        }
+      }
+    if (n.dimensions)
+      for (const t of n.dimensions) {
+        const [s, a] = t.split(".");
+        if (s === e.name && e.dimensions[a]) {
+          const r = e.dimensions[a], o = typeof r.sql == "string" ? r.sql : r.sql.toString();
+          i.push(`${o} as "${t}"`);
+        }
+      }
+    if (n.timeDimensions)
+      for (const t of n.timeDimensions) {
+        const [s, a] = t.dimension.split(".");
+        if (s === e.name && e.dimensions[a]) {
+          const r = e.dimensions[a], o = typeof r.sql == "string" ? r.sql : r.sql.toString();
+          if (t.granularity) {
+            const m = `DATE_TRUNC('${t.granularity}', ${o})`;
+            i.push(`${m} as "${t.dimension}"`);
+          } else
+            i.push(`${o} as "${t.dimension}"`);
+        }
+      }
+    return i.length > 0 ? i : ["1"];
+  }
+  buildMeasureSQL(e, n) {
+    const i = typeof e.sql == "string" ? e.sql : e.sql.toString();
+    switch (e.type) {
+      case "count":
+        return `COUNT(${i})`;
+      case "countDistinct":
+        return `COUNT(DISTINCT ${i})`;
+      case "sum":
+        return `SUM(${i})`;
+      case "avg":
+        return `AVG(${i})`;
+      case "min":
+        return `MIN(${i})`;
+      case "max":
+        return `MAX(${i})`;
+      case "number":
+        return i;
+      default:
+        return `COUNT(${i})`;
+    }
+  }
+  buildWhereClause(e, n) {
+    if (!n.filters || n.filters.length === 0)
+      return null;
+    const i = [];
+    for (const t of n.filters) {
+      const [s, a] = t.member.split(".");
+      if (s !== e.name) continue;
+      const r = e.dimensions[a] || e.measures[a];
+      if (!r) continue;
+      const o = typeof r.sql == "string" ? r.sql : r.sql.toString(), m = this.buildFilterCondition(o, t.operator, t.values);
+      m && i.push(m);
+    }
+    return i.length > 0 ? i.join(" AND ") : null;
+  }
+  buildFilterCondition(e, n, i) {
+    const t = i[0], s = typeof t == "string" ? `'${t.replace(/'/g, "''")}'` : t;
+    switch (n) {
+      case "equals":
+        return `${e} = ${s}`;
+      case "notEquals":
+        return `${e} != ${s}`;
+      case "contains":
+        return `${e} ILIKE '%${t}%'`;
+      case "notContains":
+        return `${e} NOT ILIKE '%${t}%'`;
+      case "startsWith":
+        return `${e} ILIKE '${t}%'`;
+      case "endsWith":
+        return `${e} ILIKE '%${t}'`;
+      case "gt":
+        return `${e} > ${s}`;
+      case "gte":
+        return `${e} >= ${s}`;
+      case "lt":
+        return `${e} < ${s}`;
+      case "lte":
+        return `${e} <= ${s}`;
+      case "set":
+        return `${e} IS NOT NULL`;
+      case "notSet":
+        return `${e} IS NULL`;
+      case "inDateRange":
+        return i.length >= 2 ? `${e} BETWEEN '${i[0]}' AND '${i[1]}'` : null;
+      case "beforeDate":
+        return `${e} < '${t}'`;
+      case "afterDate":
+        return `${e} > '${t}'`;
+      default:
+        return null;
+    }
+  }
+  buildGroupByClause(e, n) {
+    const i = [];
+    if (n.dimensions)
+      for (const t of n.dimensions) {
+        const [s, a] = t.split(".");
+        if (s === e.name && e.dimensions[a]) {
+          const r = e.dimensions[a], o = typeof r.sql == "string" ? r.sql : r.sql.toString();
+          i.push(o);
+        }
+      }
+    if (n.timeDimensions)
+      for (const t of n.timeDimensions) {
+        const [s, a] = t.dimension.split(".");
+        if (s === e.name && e.dimensions[a]) {
+          const r = e.dimensions[a], o = typeof r.sql == "string" ? r.sql : r.sql.toString();
+          t.granularity ? i.push(`DATE_TRUNC('${t.granularity}', ${o})`) : i.push(o);
+        }
+      }
+    return i.length > 0 ? i.join(", ") : null;
+  }
+  buildOrderByClause(e) {
+    if (!e.order || Object.keys(e.order).length === 0)
+      return null;
+    const n = [];
+    for (const [i, t] of Object.entries(e.order))
+      n.push(`"${i}" ${t.toUpperCase()}`);
+    return n.join(", ");
+  }
+  buildLimitClause(e) {
+    if (!e.limit)
+      return null;
+    let n = `LIMIT ${e.limit}`;
+    return e.offset && (n += ` OFFSET ${e.offset}`), n;
+  }
+  generateAnnotations(e, n) {
+    const i = {}, t = {}, s = {};
+    if (n.measures)
+      for (const a of n.measures) {
+        const [r, o] = a.split(".");
+        if (r === e.name && e.measures[o]) {
+          const m = e.measures[o];
+          i[a] = {
+            title: m.title || o,
+            shortTitle: m.title || o,
+            type: m.type,
+            format: m.format
+          };
+        }
+      }
+    if (n.dimensions)
+      for (const a of n.dimensions) {
+        const [r, o] = a.split(".");
+        if (r === e.name && e.dimensions[o]) {
+          const m = e.dimensions[o];
+          t[a] = {
+            title: m.title || o,
+            shortTitle: m.title || o,
+            type: m.type,
+            format: m.format
+          };
+        }
+      }
+    if (n.timeDimensions)
+      for (const a of n.timeDimensions) {
+        const [r, o] = a.dimension.split(".");
+        if (r === e.name && e.dimensions[o]) {
+          const m = e.dimensions[o];
+          s[a.dimension] = {
+            title: m.title || o,
+            shortTitle: m.title || o,
+            type: m.type,
+            granularity: a.granularity
+          };
+        }
+      }
+    return {
+      measures: i,
+      dimensions: t,
+      segments: {},
+      timeDimensions: s
+    };
+  }
+}
+class d {
+  constructor(e) {
+    c(this, "cubes", /* @__PURE__ */ new Map());
+    c(this, "dbExecutor");
+    this.dbExecutor = e;
+  }
+  setDatabaseExecutor(e) {
+    this.dbExecutor = e;
+  }
+  registerCube(e) {
+    this.validateCube(e);
+    const n = this.compileCube(e);
+    this.cubes.set(e.name, n);
+  }
+  getCube(e) {
+    return this.cubes.get(e);
+  }
+  getAllCubes() {
+    return Array.from(this.cubes.values());
+  }
+  getMetadata() {
+    return Array.from(this.cubes.values()).map((e) => this.generateCubeMetadata(e));
+  }
+  validateCube(e) {
+    if (!e.name)
+      throw new Error("Cube must have a name");
+    if (!e.sql)
+      throw new Error(`Cube ${e.name} must have SQL definition`);
+    if (!e.measures || Object.keys(e.measures).length === 0)
+      throw new Error(`Cube ${e.name} must have at least one measure`);
+  }
+  compileCube(e) {
+    return {
+      ...e,
+      queryFn: async (i, t) => {
+        if (!this.dbExecutor)
+          throw new Error("Database executor not configured. Call setDatabaseExecutor() first.");
+        return new f(this.dbExecutor).executeQuery(e, i, t);
+      }
+    };
+  }
+  generateCubeMetadata(e) {
+    const n = Object.entries(e.measures).map(([t, s]) => ({
+      name: `${e.name}.${t}`,
+      title: s.title || t,
+      shortTitle: s.title || t,
+      type: s.type,
+      format: s.format,
+      description: s.description
+    })), i = Object.entries(e.dimensions).map(([t, s]) => ({
+      name: `${e.name}.${t}`,
+      title: s.title || t,
+      shortTitle: s.title || t,
+      type: s.type,
+      format: s.format,
+      description: s.description
+    }));
+    return {
+      name: e.name,
+      title: e.title || e.name,
+      description: e.description,
+      measures: n,
+      dimensions: i,
+      segments: []
+      // Add segments support later if needed
+    };
+  }
+}
+const E = new d(), g = {
+  name: "Employees",
+  title: "Employee Analytics",
+  description: "Employee data for workforce analysis",
+  sql: `
+    SELECT 
+      e.id,
+      e.name,
+      e.email,
+      e.active,
+      e.fte_basis,
+      e.start_date,
+      e.end_date,
+      d.name as department_name,
+      s.name as supplier_name,
+      s.internal as supplier_internal
+    FROM employees e
+    LEFT JOIN departments d ON e.department = d.id
+    LEFT JOIN suppliers s ON e.supplier = s.id
+    WHERE e.organisation = \${SECURITY_CONTEXT.organisation}
+  `,
+  dimensions: {
+    id: {
+      name: "id",
+      title: "Employee ID",
+      type: "string",
+      sql: "id",
+      primaryKey: !0
+    },
+    name: {
+      name: "name",
+      title: "Employee Name",
+      type: "string",
+      sql: "name"
+    },
+    email: {
+      name: "email",
+      title: "Email",
+      type: "string",
+      sql: "email"
+    },
+    active: {
+      name: "active",
+      title: "Active Status",
+      type: "boolean",
+      sql: "active"
+    },
+    departmentName: {
+      name: "departmentName",
+      title: "Department",
+      type: "string",
+      sql: "department_name"
+    },
+    supplierName: {
+      name: "supplierName",
+      title: "Supplier",
+      type: "string",
+      sql: "supplier_name"
+    },
+    supplierType: {
+      name: "supplierType",
+      title: "Supplier Type",
+      type: "string",
+      sql: "CASE WHEN supplier_internal THEN 'Internal' ELSE 'External' END"
+    },
+    startDate: {
+      name: "startDate",
+      title: "Start Date",
+      type: "time",
+      sql: "start_date"
+    }
+  },
+  measures: {
+    count: {
+      name: "count",
+      title: "Employee Count",
+      type: "count",
+      sql: "id"
+    },
+    activeCount: {
+      name: "activeCount",
+      title: "Active Employees",
+      type: "count",
+      sql: "id",
+      filters: [{ sql: "active = true" }]
+    },
+    totalFte: {
+      name: "totalFte",
+      title: "Total FTE",
+      type: "sum",
+      sql: "fte_basis",
+      format: "number"
+    },
+    averageFte: {
+      name: "averageFte",
+      title: "Average FTE",
+      type: "avg",
+      sql: "fte_basis",
+      format: "number"
+    }
+  }
+}, C = {
+  name: "Departments",
+  title: "Department Analytics",
+  description: "Organizational department data",
+  sql: `
+    SELECT 
+      d.id,
+      d.name,
+      d.description,
+      COUNT(e.id) as employee_count
+    FROM departments d
+    LEFT JOIN employees e ON d.id = e.department AND e.active = true
+    WHERE d.organisation = \${SECURITY_CONTEXT.organisation}
+    GROUP BY d.id, d.name, d.description
+  `,
+  dimensions: {
+    id: {
+      name: "id",
+      title: "Department ID",
+      type: "string",
+      sql: "id",
+      primaryKey: !0
+    },
+    name: {
+      name: "name",
+      title: "Department Name",
+      type: "string",
+      sql: "name"
+    },
+    description: {
+      name: "description",
+      title: "Description",
+      type: "string",
+      sql: "description"
+    }
+  },
+  measures: {
+    count: {
+      name: "count",
+      title: "Department Count",
+      type: "count",
+      sql: "id"
+    },
+    employeeCount: {
+      name: "employeeCount",
+      title: "Employee Count",
+      type: "sum",
+      sql: "employee_count"
+    }
+  }
+}, $ = {
+  name: "EmployeeDepartments",
+  title: "Employee Department Analysis",
+  description: "Combined employee and department analytics",
+  sql: `
+    SELECT 
+      e.id as employee_id,
+      e.name as employee_name,
+      e.active,
+      e.fte_basis,
+      d.id as department_id,
+      d.name as department_name
+    FROM employees e
+    LEFT JOIN departments d ON e.department = d.id
+    WHERE e.organisation = \${SECURITY_CONTEXT.organisation}
+  `,
+  dimensions: {
+    employeeName: {
+      name: "employeeName",
+      title: "Employee Name",
+      type: "string",
+      sql: "employee_name"
+    },
+    departmentName: {
+      name: "departmentName",
+      title: "Department Name",
+      type: "string",
+      sql: "department_name"
+    },
+    active: {
+      name: "active",
+      title: "Active",
+      type: "boolean",
+      sql: "active"
+    }
+  },
+  measures: {
+    employeeCount: {
+      name: "employeeCount",
+      title: "Employee Count",
+      type: "count",
+      sql: "employee_id"
+    },
+    activeEmployeeCount: {
+      name: "activeEmployeeCount",
+      title: "Active Employee Count",
+      type: "count",
+      sql: "employee_id",
+      filters: [{ sql: "active = true" }]
+    },
+    totalFte: {
+      name: "totalFte",
+      title: "Total FTE",
+      type: "sum",
+      sql: "fte_basis"
+    }
+  }
+}, T = [
+  g,
+  C,
+  $
+], v = E;
+function q(l) {
+  return new d(l);
+}
+const D = {
+  /**
+   * Create a simple query builder
+   */
+  query: (l) => {
+    const e = (n, i = [], t = [], s = [], a, r) => ({
+      measures: n,
+      dimensions: i,
+      filters: t,
+      timeDimensions: s,
+      limit: a,
+      order: r
+    });
+    return {
+      measures: (n) => ({
+        dimensions: (i = []) => ({
+          filters: (t = []) => ({
+            timeDimensions: (s = []) => ({
+              limit: (a) => ({
+                order: (r) => e(n, i, t, s, a, r)
+              }),
+              order: (a) => e(n, i, t, s, void 0, a)
+            }),
+            limit: (s) => ({
+              order: (a) => e(n, i, t, [], s, a)
+            }),
+            order: (s) => e(n, i, t, [], void 0, s)
+          }),
+          timeDimensions: (t = []) => ({
+            filters: (s = []) => ({
+              limit: (a) => ({
+                order: (r) => e(n, i, s, t, a, r)
+              }),
+              order: (a) => e(n, i, s, t, void 0, a)
+            }),
+            limit: (s) => ({
+              order: (a) => e(n, i, [], t, s, a)
+            }),
+            order: (s) => e(n, i, [], t, void 0, s)
+          }),
+          limit: (t) => ({
+            order: (s) => e(n, i, [], [], t, s)
+          }),
+          order: (t) => e(n, i, [], [], void 0, t)
+        }),
+        filters: (i = []) => ({
+          dimensions: (t = []) => ({
+            timeDimensions: (s = []) => ({
+              limit: (a) => ({
+                order: (r) => e(n, t, i, s, a, r)
+              }),
+              order: (a) => e(n, t, i, s, void 0, a)
+            }),
+            limit: (s) => ({
+              order: (a) => e(n, t, i, [], s, a)
+            }),
+            order: (s) => e(n, t, i, [], void 0, s)
+          }),
+          timeDimensions: (t = []) => ({
+            dimensions: (s = []) => ({
+              limit: (a) => ({
+                order: (r) => e(n, s, i, t, a, r)
+              }),
+              order: (a) => e(n, s, i, t, void 0, a)
+            }),
+            limit: (s) => ({
+              order: (a) => e(n, [], i, t, s, a)
+            }),
+            order: (s) => e(n, [], i, t, void 0, s)
+          }),
+          limit: (t) => ({
+            order: (s) => e(n, [], i, [], t, s)
+          }),
+          order: (t) => e(n, [], i, [], void 0, t)
+        })
+      })
+    };
+  },
+  /**
+   * Create filters
+   */
+  filters: {
+    equals: (l, e) => ({ member: l, operator: "equals", values: [e] }),
+    notEquals: (l, e) => ({ member: l, operator: "notEquals", values: [e] }),
+    contains: (l, e) => ({ member: l, operator: "contains", values: [e] }),
+    greaterThan: (l, e) => ({ member: l, operator: "gt", values: [e] }),
+    lessThan: (l, e) => ({ member: l, operator: "lt", values: [e] }),
+    inDateRange: (l, e, n) => ({
+      member: l,
+      operator: "inDateRange",
+      values: [e, n]
+    }),
+    set: (l) => ({ member: l, operator: "set", values: [] }),
+    notSet: (l) => ({ member: l, operator: "notSet", values: [] })
+  },
+  /**
+   * Create time dimensions
+   */
+  timeDimensions: {
+    create: (l, e, n) => ({
+      dimension: l,
+      granularity: e,
+      dateRange: n
+    })
+  }
+};
+export {
+  d as SemanticLayerCompiler,
+  D as SemanticLayerUtils,
+  f as SemanticQueryExecutor,
+  q as createSemanticLayer,
+  v as defaultSemanticLayer,
+  C as departmentsCube,
+  $ as employeeDepartmentsCube,
+  g as employeesCube,
+  T as exampleCubes,
+  E as semanticLayer
+};

package/package.json

@@ -0,0 +1,102 @@
+{
+  "name": "drizzle-cube",
+  "version": "0.1.0",
+  "description": "A Cube.js-compatible semantic layer for Drizzle ORM with React analytics dashboard",
+  "main": "./dist/server/index.js",
+  "types": "./dist/server/index.d.ts",
+  "type": "module",
+  "exports": {
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "import": "./dist/server/index.js"
+    },
+    "./client": {
+      "types": "./dist/client/index.d.ts",
+      "import": "./dist/client/index.js"
+    },
+    "./adapters/hono": {
+      "types": "./dist/adapters/hono/index.d.ts",
+      "import": "./dist/adapters/hono/index.js"
+    }
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "dev": "concurrently \"npm run dev:server\" \"npm run dev:client\" \"npm run dev:examples\"",
+    "dev:server": "vite build src/server --watch --mode development",
+    "dev:client": "vite build src/client --watch --mode development",
+    "dev:examples": "cd examples/hono-app && npm run dev",
+    "dev:help": "cd help-site && npm run dev",
+    "build": "npm run build:server && npm run build:client && npm run build:adapters",
+    "build:server": "vite build --config vite.config.server.ts",
+    "build:client": "vite build --config vite.config.client.ts",
+    "build:adapters": "vite build --config vite.config.adapters.ts",
+    "build:help": "cd help-site && npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/**/*.ts",
+    "lint:fix": "eslint src/**/*.ts --fix",
+    "prepublishOnly": "npm run build && npm run test && npm run typecheck"
+  },
+  "keywords": [
+    "drizzle",
+    "cube",
+    "cubejs",
+    "semantic-layer",
+    "analytics",
+    "dashboard",
+    "react",
+    "typescript"
+  ],
+  "author": "Clifton Cunningham <clifton@clifton.io>",
+  "license": "MIT",
+  "homepage": "https://drizzle-cube.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cliftonc/drizzle-cube.git"
+  },
+  "bugs": {
+    "url": "https://github.com/cliftonc/drizzle-cube/issues"
+  },
+  "peerDependencies": {
+    "drizzle-orm": "^0.33.0",
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": false
+    },
+    "react-dom": {
+      "optional": false
+    },
+    "drizzle-orm": {
+      "optional": false
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/react": "^18.0.0",
+    "@types/react-dom": "^18.0.0",
+    "@typescript-eslint/eslint-plugin": "^7.18.0",
+    "@typescript-eslint/parser": "^7.18.0",
+    "@vitejs/plugin-react": "^4.0.0",
+    "concurrently": "^8.0.0",
+    "eslint": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vite": "^5.0.0",
+    "vite-plugin-dts": "^4.0.0",
+    "vitest": "^2.0.0"
+  },
+  "dependencies": {
+    "@heroicons/react": "^2.0.0",
+    "react-grid-layout": "^1.4.0",
+    "react-hook-form": "^7.47.0",
+    "recharts": "^2.8.0",
+    "zod": "^3.22.0"
+  }
+}