dzql 0.4.0 → 0.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dzql",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "PostgreSQL-powered framework with zero boilerplate CRUD operations and real-time WebSocket synchronization",
   "type": "module",
   "main": "src/server/index.js",

package/src/server/db.js

@@ -35,7 +35,10 @@ export const listen_sql = postgres(DATABASE_URL, {
   onnotice: process.env.NODE_ENV === 'test' ? () => {} : undefined,
 });
 
-dbLogger.info(`Database connected: ${DATABASE_URL.replace(/\/\/.*@/, '//***@')}`);
+// Only log connection info in development
+if (process.env.NODE_ENV !== 'production' && process.env.NODE_ENV !== 'test') {
+  dbLogger.info(`Database connected: ${DATABASE_URL.replace(/\/\/.*@/, '//***@')}`);
+}
 
 // Cache for function parameter metadata
 const functionParamCache = new Map();
@@ -170,13 +173,68 @@ export async function setupListeners(callback) {
   }
 }
 
-// DZQL Generic Operations
+// DZQL Generic Operations - Try compiled functions first, fall back to generic_exec
 export async function callDZQLOperation(operation, entity, args, userId) {
   dbLogger.trace(`DZQL ${operation}.${entity} for user ${userId}`);
-  const result = await sql`
-    SELECT dzql.generic_exec(${operation}, ${entity}, ${args}, ${userId}) as result
-  `;
-  return result[0].result;
+
+  const compiledFunctionName = `${operation}_${entity}`;
+
+  try {
+    // Try compiled function first
+    // Different operations have different signatures:
+    // - search: search_entity(p_user_id, p_filters, p_search, p_sort, p_page, p_limit)
+    // - get: get_entity(p_user_id, p_id, p_on_date)
+    // - save: save_entity(p_user_id, p_data, p_on_date)
+    // - delete: delete_entity(p_user_id, p_id)
+    // - lookup: lookup_entity(p_user_id, p_term, p_limit)
+
+    if (operation === 'search') {
+      // Extract search parameters from args
+      const filters = args.filters || args.p_filters || {};
+      const search = args.search || null;
+      const sort = args.sort || null;
+      const page = args.page || 1;
+      const limit = args.limit || 25;
+
+      const result = await sql.unsafe(`
+        SELECT ${compiledFunctionName}($1::int, $2::jsonb, $3::text, $4::jsonb, $5::int, $6::int) as result
+      `, [userId, filters, search, sort, page, limit]);
+      return result[0].result;
+    } else if (operation === 'get') {
+      const result = await sql.unsafe(`
+        SELECT ${compiledFunctionName}($1::int, $2::int, NULL) as result
+      `, [userId, args.id]);
+      return result[0].result;
+    } else if (operation === 'save') {
+      const result = await sql.unsafe(`
+        SELECT ${compiledFunctionName}($1::int, $2::jsonb, NULL) as result
+      `, [userId, args]);
+      return result[0].result;
+    } else if (operation === 'delete') {
+      const result = await sql.unsafe(`
+        SELECT ${compiledFunctionName}($1::int, $2::int) as result
+      `, [userId, args.id]);
+      return result[0].result;
+    } else if (operation === 'lookup') {
+      const result = await sql.unsafe(`
+        SELECT ${compiledFunctionName}($1::int, $2::text, $3::int) as result
+      `, [userId, args.term || '', args.limit || 10]);
+      return result[0].result;
+    } else {
+      throw new Error(`Unknown operation: ${operation}`);
+    }
+  } catch (error) {
+    // If compiled function doesn't exist, fall back to generic_exec
+    if (error.message?.includes('does not exist') || error.code === '42883') {
+      dbLogger.trace(`Compiled function ${compiledFunctionName} not found, trying generic_exec`);
+      const result = await sql`
+        SELECT dzql.generic_exec(${operation}, ${entity}, ${args}, ${userId}) as result
+      `;
+      return result[0].result;
+    }
+    // Re-throw other errors
+    throw error;
+  }
 }
 
 // DZQL nested proxy factory

package/src/server/logger.js

@@ -12,6 +12,15 @@ const LOG_LEVELS = {
 // Default log level from environment or INFO
 const DEFAULT_LEVEL = process.env.LOG_LEVEL?.toUpperCase() || "INFO";
 
+// Detect if running in CLI context (invokej/tasks.js)
+const isCliContext = () => {
+  // Check if main module contains 'tasks.js' or 'invokej'
+  const mainModule = process.argv[1] || '';
+  return mainModule.includes('tasks.js') ||
+         mainModule.includes('invokej') ||
+         mainModule.includes('invj');
+};
+
 // Parse LOG_CATEGORIES from environment
 // Format: "ws:debug,db:trace,auth:info" or "*:debug" for all
 const parseCategories = () => {
@@ -20,8 +29,9 @@ const parseCategories = () => {
 
   if (!envCategories) {
     // Default settings for development vs production
-    if (process.env.NODE_ENV === "production") {
-      categories["*"] = LOG_LEVELS.WARN;
+    // CLI context defaults to ERROR level unless explicitly configured
+    if (process.env.NODE_ENV === "production" || isCliContext()) {
+      categories["*"] = LOG_LEVELS.ERROR;  // Only errors in production/CLI
     } else if (process.env.NODE_ENV === "test") {
       categories["*"] = LOG_LEVELS.ERROR;
     } else {
@@ -220,8 +230,11 @@ export const timed = async (category, operation, fn) => {
   }
 };
 
-// Log configuration on startup (only in development)
-if (process.env.NODE_ENV !== "production" && process.env.NODE_ENV !== "test") {
+// Log configuration on startup (only in development and when explicitly debugging)
+// Suppress banner if LOG_CATEGORIES is not set (user doesn't care about logging config)
+if (process.env.NODE_ENV !== "production" &&
+    process.env.NODE_ENV !== "test" &&
+    process.env.LOG_CATEGORIES) {
   const config = getConfig();
   console.log(colors.bright + "=== Logger Configuration ===" + colors.reset);
   console.log("Categories:", config.categories);

package/src/server/namespace.js

@@ -1,12 +1,18 @@
+// Suppress logger output for CLI usage - MUST be set before any imports
+if (!process.env.NODE_ENV) {
+  process.env.NODE_ENV = 'production';
+}
+
 import { sql, db } from "./db.js";
 
 // Default user for CLI operations
 const DEFAULT_USER_ID = 1;
 
 /**
- * Discover available entities from dzql.entities table
+ * Discover available entities from dzql.entities table or compiled functions
  */
 async function discoverEntities() {
+  // First try dzql.entities table (runtime mode)
   const result = await sql`
     SELECT table_name, label_field, searchable_fields
     FROM dzql.entities
@@ -14,13 +20,36 @@ async function discoverEntities() {
   `;
 
   const entities = {};
-  for (const row of result) {
-    const searchFields = row.searchable_fields?.join(", ") || "none";
-    entities[row.table_name] = {
-      label: row.label_field,
-      searchable: row.searchable_fields || [],
-      description: `Entity: ${row.table_name} (label: ${row.label_field}, searchable: ${searchFields})`,
-    };
+
+  if (result.length > 0) {
+    // Runtime mode - use dzql.entities table
+    for (const row of result) {
+      const searchFields = row.searchable_fields?.join(", ") || "none";
+      entities[row.table_name] = {
+        label: row.label_field,
+        searchable: row.searchable_fields || [],
+        description: `Entity: ${row.table_name} (label: ${row.label_field}, searchable: ${searchFields})`,
+      };
+    }
+  } else {
+    // Compiled mode - discover from function names
+    const functions = await sql`
+      SELECT DISTINCT substring(proname from 'search_(.+)') as entity_name
+      FROM pg_proc
+      WHERE pronamespace = (SELECT oid FROM pg_namespace WHERE nspname = 'public')
+      AND proname LIKE 'search_%'
+      AND substring(proname from 'search_(.+)') IS NOT NULL
+      ORDER BY entity_name
+    `;
+
+    for (const row of functions) {
+      const entityName = row.entity_name;
+      entities[entityName] = {
+        label: 'id',  // Default, since we can't know from functions alone
+        searchable: [],
+        description: `Entity: ${entityName} (compiled mode)`,
+      };
+    }
   }
 
   return entities;