drizzle-cube 0.1.1 → 0.1.3

package/README.md

@@ -4,6 +4,10 @@
 
 Transform your Drizzle schema into a powerful, type-safe analytics platform with SQL injection protection and full TypeScript support.
 
+> **⚠️ DEVELOPMENT WARNING**  
+> **This project is under active development and is not yet fully functional. I will update here when we reach an alpha/working version!**  
+> Feel free to star ⭐ the repo to stay updated on progress.
+
 [![NPM Version](https://img.shields.io/npm/v/drizzle-cube)](https://www.npmjs.com/package/drizzle-cube)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue)](https://www.typescriptlang.org/)
 [![Drizzle ORM](https://img.shields.io/badge/Drizzle%20ORM-0.33+-green)](https://orm.drizzle.team/)
@@ -54,29 +58,68 @@ export const schema = { employees, departments }
 
 ```typescript
 // cubes.ts
-import { defineCube, eq } from 'drizzle-cube/server'
+import { defineCube } from 'drizzle-cube/server'
+import { eq } from 'drizzle-orm'
 import { schema } from './schema'
 
-export const employeesCube = defineCube(schema, {
-  name: 'Employees',
+export const employeesCube = defineCube('Employees', {
+  title: 'Employee Analytics',
   
-  // Use Drizzle query builder for type safety
-  sql: ({ db, securityContext }) => 
-    db.select()
-      .from(schema.employees)
-      .leftJoin(schema.departments, eq(schema.employees.departmentId, schema.departments.id))
-      .where(eq(schema.employees.organisationId, securityContext.organisationId)),
+  // Use Drizzle query structure for type safety
+  sql: (ctx) => ({
+    from: schema.employees,
+    joins: [
+      {
+        table: schema.departments,
+        on: eq(schema.employees.departmentId, schema.departments.id),
+        type: 'left'
+      }
+    ],
+    where: eq(schema.employees.organisationId, ctx.securityContext.organisationId)
+  }),
   
   dimensions: {
-    name: { sql: schema.employees.name, type: 'string' },
-    email: { sql: schema.employees.email, type: 'string' },
-    departmentName: { sql: schema.departments.name, type: 'string' }
+    name: {
+      name: 'name',
+      title: 'Employee Name',
+      sql: schema.employees.name,
+      type: 'string'
+    },
+    email: {
+      name: 'email', 
+      title: 'Email Address',
+      sql: schema.employees.email,
+      type: 'string'
+    },
+    departmentName: {
+      name: 'departmentName',
+      title: 'Department',
+      sql: schema.departments.name,
+      type: 'string'
+    }
   },
   
   measures: {
-    count: { sql: schema.employees.id, type: 'count' },
-    totalSalary: { sql: schema.employees.salary, type: 'sum', format: 'currency' },
-    avgSalary: { sql: schema.employees.salary, type: 'avg', format: 'currency' }
+    count: {
+      name: 'count',
+      title: 'Total Employees',
+      sql: schema.employees.id,
+      type: 'count'
+    },
+    totalSalary: {
+      name: 'totalSalary',
+      title: 'Total Salary',
+      sql: schema.employees.salary,
+      type: 'sum',
+      format: 'currency'
+    },
+    avgSalary: {
+      name: 'avgSalary',
+      title: 'Average Salary', 
+      sql: schema.employees.salary,
+      type: 'avg',
+      format: 'currency'
+    }
   }
 })
 ```
@@ -89,13 +132,19 @@ import { drizzle } from 'drizzle-orm/postgres-js'
 import { createCubeApp } from 'drizzle-cube/adapters/hono'
 import { SemanticLayerCompiler } from 'drizzle-cube/server'
 import postgres from 'postgres'
+import { schema } from './schema'
+import { employeesCube } from './cubes'
 
 // Setup Drizzle
 const client = postgres(process.env.DATABASE_URL!)
 const db = drizzle(client, { schema })
 
 // Create semantic layer
-const semanticLayer = new SemanticLayerCompiler({ drizzle: db, schema })
+const semanticLayer = new SemanticLayerCompiler({
+  drizzle: db,
+  schema,
+  engineType: 'postgres'
+})
 semanticLayer.registerCube(employeesCube)
 
 // Create API server with Cube.js compatibility
@@ -161,10 +210,19 @@ const condition = eq(schema.employees.name, userInput)
 Get full TypeScript support from your database schema to your analytics:
 
 ```typescript
-const cube = defineCube(schema, {
+const cube = defineCube('Employees', {
   dimensions: {
-    name: { sql: schema.employees.name },        // ✅ Type-safe
-    invalid: { sql: schema.employees.invalidCol } // ❌ TypeScript error
+    name: {
+      name: 'name',
+      title: 'Employee Name',
+      sql: schema.employees.name,        // ✅ Type-safe
+      type: 'string'
+    },
+    invalid: {
+      name: 'invalid',
+      sql: schema.employees.invalidCol,  // ❌ TypeScript error
+      type: 'string'
+    }
   }
 })
 ```
@@ -186,82 +244,54 @@ Works with multiple frameworks via adapter pattern:
 
 ## Advanced Usage
 
-### Complex Queries with CTEs
+
+### Advanced Security with Row-Level Security
 
 ```typescript
-const advancedCube = defineCube(schema, {
-  name: 'DepartmentAnalytics',
+import { and, sql } from 'drizzle-orm'
+
+const secureCube = defineCube('SecureEmployees', {
+  title: 'Secure Employee Data',
   
-  sql: ({ db, securityContext }) => sql`
-    WITH department_stats AS (
-      SELECT 
-        d.id,
-        d.name,
-        COUNT(e.id) as employee_count,
-        AVG(e.salary) as avg_salary
-      FROM ${schema.departments} d
-      LEFT JOIN ${schema.employees} e ON d.id = e.department_id
-      WHERE d.organisation_id = ${securityContext.organisationId}
-      GROUP BY d.id, d.name
+  sql: (ctx) => ({
+    from: schema.employees,
+    where: and(
+      eq(schema.employees.organisationId, ctx.securityContext.organisationId),
+      // Only show employees user has permission to see
+      ctx.securityContext.role === 'admin' 
+        ? sql`true`
+        : eq(schema.employees.managerId, ctx.securityContext.userId)
     )
-    SELECT * FROM department_stats
-  `,
+  }),
   
   dimensions: {
-    name: { sql: sql`name`, type: 'string' }
+    name: {
+      name: 'name',
+      title: 'Employee Name',
+      sql: schema.employees.name,
+      type: 'string'
+    }
   },
   
   measures: {
-    employeeCount: { sql: sql`employee_count`, type: 'number' },
-    avgSalary: { sql: sql`avg_salary`, type: 'number', format: 'currency' }
+    count: {
+      name: 'count',
+      title: 'Employee Count',
+      sql: schema.employees.id,
+      type: 'count'
+    }
   }
 })
 ```
 
-### Advanced Security with Row-Level Security
-
-```typescript
-const secureCube = defineCube(schema, {
-  name: 'SecureEmployees',
-  
-  sql: ({ db, securityContext }) => 
-    db.select()
-      .from(schema.employees)
-      .where(
-        and(
-          eq(schema.employees.organisationId, securityContext.organisationId),
-          // Only show employees user has permission to see
-          securityContext.role === 'admin' 
-            ? sql`true`
-            : eq(schema.employees.managerId, securityContext.userId)
-        )
-      )
-})
-```
-
-### Multiple Database Support
-
-```typescript
-// PostgreSQL
-import { drizzle } from 'drizzle-orm/postgres-js'
-import postgres from 'postgres'
-
-// MySQL  
-import { drizzle } from 'drizzle-orm/mysql2'
-import mysql from 'mysql2/promise'
-
-// SQLite
-import { drizzle } from 'drizzle-orm/better-sqlite3'
-import Database from 'better-sqlite3'
-```
 
 ## API Reference
 
 ### Core Functions
 
-- `defineCube(schema, definition)` - Create type-safe cube
-- `createSemanticLayer({ drizzle, schema })` - Setup semantic layer
-- `createCubeApp(options)` - Create Cube.js API server
+- `defineCube(name, definition)` - Create type-safe cube with name and configuration
+- `SemanticLayerCompiler({ drizzle, schema, engineType })` - Setup semantic layer compiler
+- `createCubeApp(options)` - Create Cube.js-compatible API server
 
 ### Supported Drizzle Features
 
@@ -288,17 +318,11 @@ Supports all Cube.js filter operators with Drizzle safety:
 
 ## Documentation
 
-📚 **[Complete Documentation](https://drizzle-cube.dev)**  
-🏗️ **[API Reference](https://drizzle-cube.dev/api)**  
-🎯 **[Drizzle Integration Guide](./docs/drizzle-integration.md)**  
-🚀 **[Migration Guide](https://drizzle-cube.dev/migration)**  
+Coming soon! 📚
 
 ## Examples
 
-- **[Basic Hono App](./examples/hono-basic/)**
-- **[Advanced Security](./examples/hono-security/)**
-- **[Multi-tenant SaaS](./examples/multi-tenant/)**
-- **[Real-time Dashboard](./examples/dashboard/)**
+Coming soon! Check the test files for usage patterns in the meantime.
 
 ## Contributing
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drizzle-cube",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Drizzle ORM-first semantic layer with Cube.js compatibility. Type-safe analytics and dashboards with SQL injection protection.",
   "main": "./dist/server/index.js",
   "types": "./dist/server/index.d.ts",