dzql 0.2.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dzql",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "PostgreSQL-powered framework with zero boilerplate CRUD operations and real-time WebSocket synchronization",
   "type": "module",
   "main": "src/server/index.js",
@@ -22,13 +22,12 @@
   ],
   "scripts": {
     "test": "bun test",
-    "prepublishOnly": "echo '✅ Publishing DZQL v0.2.0...'"
+    "prepublishOnly": "echo '✅ Publishing DZQL v0.2.1...'"
   },
   "dependencies": {
     "jose": "^6.1.0",
     "postgres": "^3.4.7"
   },
-
   "keywords": [
     "postgresql",
     "postgres",

package/src/compiler/cli/compile-example.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env bun
+
+import { readFileSync } from 'fs';
+import { compileSubscribablesFromSQL } from '../compiler.js';
+
+const sqlContent = readFileSync('./examples/subscribables/venue_detail_simple.sql', 'utf-8');
+
+console.log('Compiling subscribable...\n');
+
+try {
+  const result = compileSubscribablesFromSQL(sqlContent);
+
+  console.log('Summary:', result.summary);
+
+  if (result.errors.length > 0) {
+    console.log('\nErrors:');
+    result.errors.forEach(err => {
+      console.log(`  ${err.subscribable}: ${err.error}`);
+    });
+  }
+
+  if (result.results.length > 0) {
+    const compiled = result.results[0];
+    console.log(`\n✓ Compiled '${compiled.name}' successfully!`);
+    console.log(`  Checksum: ${compiled.checksum.substring(0, 16)}...`);
+    console.log(`  Time: ${compiled.compilationTime}ms`);
+    console.log('\nGenerated SQL:\n');
+    console.log(compiled.sql);
+  }
+} catch (error) {
+  console.error('Error:', error.message);
+  process.exit(1);
+}

package/src/compiler/cli/compile-subscribable.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env bun
+
+/**
+ * Compile subscribable and output SQL only (for piping to psql)
+ */
+
+import { readFileSync } from 'fs';
+import { compileSubscribablesFromSQL } from '../compiler.js';
+
+const args = process.argv.slice(2);
+if (args.length === 0) {
+  console.error('Usage: compile-subscribable.js <sql-file>');
+  process.exit(1);
+}
+
+const sqlFile = args[0];
+
+try {
+  const sqlContent = readFileSync(sqlFile, 'utf-8');
+  const result = compileSubscribablesFromSQL(sqlContent);
+
+  if (result.errors.length > 0) {
+    console.error('Compilation errors:');
+    result.errors.forEach(err => {
+      console.error(`  ${err.subscribable}: ${err.error}`);
+    });
+    process.exit(1);
+  }
+
+  if (result.results.length === 0) {
+    console.error('No subscribables found in', sqlFile);
+    process.exit(1);
+  }
+
+  // Output just the SQL
+  for (const compiled of result.results) {
+    console.log(compiled.sql);
+    console.log(''); // Blank line between subscribables
+  }
+} catch (error) {
+  console.error('Error:', error.message);
+  process.exit(1);
+}

package/src/compiler/cli/debug-compile.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env bun
+
+/**
+ * Test script for subscribable compilation
+ */
+
+import { readFileSync } from 'fs';
+import { compileSubscribablesFromSQL } from './src/compiler/compiler.js';
+
+// Read the example subscribable
+const sqlContent = readFileSync('./examples/subscribables/venue_detail_subscribable.sql', 'utf-8');
+
+console.log('Compiling subscribable...\n');
+
+try {
+  const result = compileSubscribablesFromSQL(sqlContent);
+
+  console.log('Compilation Summary:');
+  console.log(`  Total: ${result.summary.total}`);
+  console.log(`  Successful: ${result.summary.successful}`);
+  console.log(`  Failed: ${result.summary.failed}\n`);
+
+  if (result.errors.length > 0) {
+    console.log('Errors:');
+    result.errors.forEach(err => {
+      console.log(`  - ${err.subscribable}: ${err.error}`);
+    });
+    console.log('');
+  }
+
+  if (result.results.length > 0) {
+    const compiled = result.results[0];
+    console.log(`Generated SQL for '${compiled.name}':`);
+    console.log('='.repeat(80));
+    console.log(compiled.sql);
+    console.log('='.repeat(80));
+    console.log(`\nChecksum: ${compiled.checksum}`);
+    console.log(`Compilation time: ${compiled.compilationTime}ms`);
+  }
+} catch (error) {
+  console.error('Compilation failed:', error.message);
+  console.error(error.stack);
+  process.exit(1);
+}

package/src/compiler/cli/debug-parse.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env bun
+
+/**
+ * Test script for subscribable parsing (debug)
+ */
+
+import { readFileSync } from 'fs';
+import { SubscribableParser } from './src/compiler/parser/subscribable-parser.js';
+
+// Read the example subscribable
+const sqlContent = readFileSync('./examples/subscribables/venue_detail_subscribable.sql', 'utf-8');
+
+console.log('Parsing subscribable...\n');
+
+const parser = new SubscribableParser();
+const subscribables = parser.parseAllFromSQL(sqlContent);
+
+console.log('Found', subscribables.length, 'subscribables\n');
+
+for (const sub of subscribables) {
+  console.log('Subscribable:', sub.name);
+  console.log('Root Entity:', sub.rootEntity);
+  console.log('Permission Paths:', JSON.stringify(sub.permissionPaths, null, 2));
+  console.log('Param Schema:', JSON.stringify(sub.paramSchema, null, 2));
+  console.log('Relations:', JSON.stringify(sub.relations, null, 2));
+}

package/src/compiler/cli/debug-path-parser.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env bun
+
+import { PathParser } from './src/compiler/parser/path-parser.js';
+
+const parser = new PathParser();
+
+const testPath = '@org_id->acts_for[org_id=$]{active}.user_id';
+
+console.log('Parsing path:', testPath);
+console.log('');
+
+try {
+  const ast = parser.parse(testPath);
+  console.log('AST:', JSON.stringify(ast, null, 2));
+} catch (error) {
+  console.error('Error:', error.message);
+  console.error(error.stack);
+}

package/src/compiler/cli/debug-subscribable-parser.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env bun
+
+import { SubscribableParser } from '../parser/subscribable-parser.js';
+import { readFileSync } from 'fs';
+
+const sqlContent = readFileSync('./examples/subscribables/venue_detail_simple.sql', 'utf-8');
+
+console.log('Parsing subscribable...\n');
+
+const parser = new SubscribableParser();
+const subscribables = parser.parseAllFromSQL(sqlContent);
+
+console.log('Found:', subscribables.length, 'subscribables\n');
+
+for (const sub of subscribables) {
+  console.log('Name:', sub.name);
+  console.log('Root Entity:', sub.rootEntity);
+  console.log('Permission Paths:', JSON.stringify(sub.permissionPaths, null, 2));
+  console.log('Param Schema:', JSON.stringify(sub.paramSchema, null, 2));
+  console.log('Relations:', JSON.stringify(sub.relations, null, 2));
+}

package/src/compiler/codegen/subscribable-codegen.js

@@ -78,14 +78,59 @@ END;
 $$ LANGUAGE plpgsql STABLE SECURITY DEFINER;`;
     }
 
+    // Check if any path references root entity fields (needs database lookup)
+    const needsEntityLookup = subscribePaths.some(path => {
+      const ast = this.parser.parse(path);
+      return ast.type === 'direct_field' || ast.type === 'field_ref';
+    });
+
     // Generate permission check logic
     const checks = subscribePaths.map(path => {
       const ast = this.parser.parse(path);
-      return this._generatePathCheck(ast, 'p_params', 'p_user_id');
+      return this._generatePathCheck(ast, needsEntityLookup ? 'entity' : 'p_params', 'p_user_id');
     });
 
     const checkSQL = checks.join(' OR\n    ');
 
+    // If we need entity lookup, fetch it first
+    if (needsEntityLookup) {
+      const params = Object.keys(this.paramSchema);
+      const paramDeclarations = params.map(p => `  v_${p} ${this.paramSchema[p]};`).join('\n');
+      const paramExtractions = params.map(p =>
+        `  v_${p} := (p_params->>'${p}')::${this.paramSchema[p]};`
+      ).join('\n');
+
+      const rootFilter = this._generateRootFilter();
+
+      return `CREATE OR REPLACE FUNCTION ${this.name}_can_subscribe(
+  p_user_id INT,
+  p_params JSONB
+) RETURNS BOOLEAN AS $$
+DECLARE
+${paramDeclarations}
+  entity RECORD;
+BEGIN
+  -- Extract parameters
+${paramExtractions}
+
+  -- Fetch entity
+  SELECT * INTO entity
+  FROM ${this.rootEntity} root
+  WHERE ${rootFilter};
+
+  -- Entity not found
+  IF NOT FOUND THEN
+    RETURN FALSE;
+  END IF;
+
+  -- Check permissions
+  RETURN (
+    ${checkSQL}
+  );
+END;
+$$ LANGUAGE plpgsql STABLE SECURITY DEFINER;`;
+    }
+
     return `CREATE OR REPLACE FUNCTION ${this.name}_can_subscribe(
   p_user_id INT,
   p_params JSONB
@@ -104,7 +149,12 @@ $$ LANGUAGE plpgsql STABLE SECURITY DEFINER;`;
    */
   _generatePathCheck(ast, recordVar, userIdVar) {
     // Handle direct field reference: @owner_id
-    if (ast.type === 'field_ref') {
+    if (ast.type === 'direct_field' || ast.type === 'field_ref') {
+      // If recordVar is 'entity' (RECORD type), access directly
+      if (recordVar === 'entity') {
+        return `${recordVar}.${ast.field} = ${userIdVar}`;
+      }
+      // Otherwise it's p_params (JSONB type)
       return `(${recordVar}->>'${ast.field}')::int = ${userIdVar}`;
     }
 

package/src/client/stores/README.md

@@ -1,95 +0,0 @@
-# DZQL Canonical Pinia Stores
-
-**The official, AI-friendly Pinia stores for DZQL Vue.js applications.**
-
-## Why These Stores Exist
-
-When building DZQL apps, developers (and AI assistants) often struggle with:
-
-1. **Three-phase lifecycle** - connecting → login → ready
-2. **WebSocket connection management** - reconnection, error handling
-3. **Authentication flow** - token storage, profile management  
-4. **Router integration** - navigation, state synchronization
-5. **Inconsistent patterns** - every project does it differently
-
-These canonical stores solve all of these problems with a **simple, consistent pattern** that AI can easily understand and replicate.
-
-## The Stores
-
-### `useWsStore` - WebSocket & Auth
-
-Manages:
-- WebSocket connection (with auto-reconnect)
-- User authentication (login/register/logout)
-- Connection state tracking
-- Three-phase app lifecycle
-
-### `useAppStore` - Application State
-
-Manages:
-- App initialization
-- Router integration
-- Entity metadata caching
-- Navigation helpers
-- UI state (sidebars, panels)
-
-## Quick Example
-
-```vue
-<script setup>
-import { computed } from 'vue'
-import { useWsStore, useAppStore } from 'dzql/client/stores'
-
-const wsStore = useWsStore()
-const appStore = useAppStore()
-
-const state = computed(() => wsStore.appState)
-const ws = wsStore.getWs()
-
-// Use DZQL API
-const venues = await ws.api.search.venues({ limit: 50 })
-</script>
-
-<template>
-  <!-- Three-phase lifecycle -->
-  <div v-if="state === 'connecting'">Connecting...</div>
-  <LoginView v-else-if="state === 'login'" />
-  <MainApp v-else-if="state === 'ready'" />
-</template>
-```
-
-## Documentation
-
-- **[Quick Start](../../../docs/CLIENT-QUICK-START.md)** - Get running in 5 minutes
-- **[Complete Guide](../../../docs/CLIENT-STORES.md)** - Full API reference and patterns
-
-## Files
-
-- `useWsStore.js` - WebSocket connection and authentication
-- `useAppStore.js` - Application state and navigation
-- `index.js` - Exports both stores
-
-## For AI Assistants
-
-When helping users with DZQL apps:
-
-1. **Always use these stores** - Don't create custom connection logic
-2. **Follow the three-phase lifecycle** - connecting → login → ready
-3. **Use computed for reactive state** - `const profile = computed(() => wsStore.profile)`
-4. **Get WS instance for API calls** - `const ws = wsStore.getWs()`
-
-**Example prompt for AI:**
-
-> "I'm using the canonical DZQL stores from `dzql/client/stores`. The pattern is:
-> 1. useWsStore for WebSocket connection (three phases: connecting, login, ready)
-> 2. useAppStore for app state and navigation
-> 3. Access DZQL API via `wsStore.getWs().api.get.venues({ id: 1 })`
-> Please follow this pattern."
-
-## Version
-
-These stores are available in DZQL v0.1.6+
-
-## License
-
-MIT