dzql 0.3.7 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dzql",
-  "version": "0.3.7",
+  "version": "0.4.1",
   "description": "PostgreSQL-powered framework with zero boilerplate CRUD operations and real-time WebSocket synchronization",
   "type": "module",
   "main": "src/server/index.js",
@@ -11,7 +11,8 @@
     "./client/templates": "./src/client/templates/App.vue",
     "./server": "./src/server/index.js",
     "./db": "./src/server/db.js",
-    "./compiler": "./src/compiler/index.js"
+    "./compiler": "./src/compiler/index.js",
+    "./namespace": "./src/server/namespace.js"
   },
   "files": [
     "bin/**/*.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,93 @@ export async function setupListeners(callback) {
   }
 }
 
+// Cache for mode detection (null = not checked, true = compiled, false = runtime)
+let isCompiledMode = null;
+
+// Auto-detect if we're in compiled or runtime mode
+async function detectMode() {
+  if (isCompiledMode !== null) {
+    return isCompiledMode;
+  }
+
+  try {
+    // Check if dzql.generic_exec exists
+    const result = await sql`
+      SELECT 1 FROM pg_proc
+      WHERE proname = 'generic_exec'
+      AND pronamespace = (SELECT oid FROM pg_namespace WHERE nspname = 'dzql')
+      LIMIT 1
+    `;
+    isCompiledMode = result.length === 0; // If no results, it's compiled mode
+    dbLogger.trace(isCompiledMode ? 'Detected compiled mode' : 'Detected runtime mode');
+  } catch (error) {
+    // If there's an error checking, assume runtime mode
+    isCompiledMode = false;
+    dbLogger.trace('Error detecting mode, assuming runtime mode');
+  }
+
+  return isCompiledMode;
+}
+
 // DZQL Generic Operations
 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 compiled = await detectMode();
+
+  if (!compiled) {
+    // Runtime mode - use generic_exec
+    const result = await sql`
+      SELECT dzql.generic_exec(${operation}, ${entity}, ${args}, ${userId}) as result
+    `;
+    return result[0].result;
+  } else {
+    // Compiled mode - call compiled function directly
+    const compiledFunctionName = `${operation}_${entity}`;
+
+    // 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}`);
+    }
+  }
 }
 
 // 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

@@ -0,0 +1,233 @@
+// 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
+ */
+async function discoverEntities() {
+  const result = await sql`
+    SELECT table_name, label_field, searchable_fields
+    FROM dzql.entities
+    ORDER BY table_name
+  `;
+
+  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})`,
+    };
+  }
+
+  return entities;
+}
+
+/**
+ * DZQL operations namespace - provides CLI-style access to DZQL operations
+ *
+ * Usage in tasks.js:
+ * ```js
+ * import { DzqlNamespace } from 'dzql/namespace';
+ *
+ * export class Tasks {
+ *   constructor() {
+ *     this.dzql = new DzqlNamespace();
+ *   }
+ * }
+ * ```
+ */
+export class DzqlNamespace {
+  constructor(userId = DEFAULT_USER_ID) {
+    this.userId = userId;
+  }
+
+  /** List all available entities */
+  async entities(c) {
+    try {
+      const entities = await discoverEntities();
+      console.log(JSON.stringify({ success: true, entities }, null, 2));
+      await sql.end();
+    } catch (error) {
+      console.error(
+        JSON.stringify({ success: false, error: error.message }, null, 2),
+      );
+      await sql.end();
+      process.exit(1);
+    }
+  }
+
+  /** Search an entity */
+  async search(c, entity, argsJson = "{}") {
+    if (!entity) {
+      console.error("Error: entity name required");
+      console.error("Usage: invokej dzql.search <entity> '<json_args>'");
+      console.error(
+        'Example: invokej dzql.search organisations \'{"query": "test"}\'',
+      );
+      await sql.end();
+      process.exit(1);
+    }
+
+    let args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      console.error("Error: arguments must be valid JSON");
+      await sql.end();
+      process.exit(1);
+    }
+
+    try {
+      const result = await db.api.search[entity](args, this.userId);
+      console.log(JSON.stringify({ success: true, result }, null, 2));
+      await sql.end();
+    } catch (error) {
+      console.error(
+        JSON.stringify({ success: false, error: error.message }, null, 2),
+      );
+      await sql.end();
+      process.exit(1);
+    }
+  }
+
+  /** Get entity by ID */
+  async get(c, entity, argsJson = "{}") {
+    if (!entity) {
+      console.error("Error: entity name required");
+      console.error("Usage: invokej dzql.get <entity> '<json_args>'");
+      console.error("Example: invokej dzql.get venues '{\"id\": 1}'");
+      await sql.end();
+      process.exit(1);
+    }
+
+    let args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      console.error("Error: arguments must be valid JSON");
+      await sql.end();
+      process.exit(1);
+    }
+
+    try {
+      const result = await db.api.get[entity](args, this.userId);
+      console.log(JSON.stringify({ success: true, result }, null, 2));
+      await sql.end();
+    } catch (error) {
+      console.error(
+        JSON.stringify({ success: false, error: error.message }, null, 2),
+      );
+      await sql.end();
+      process.exit(1);
+    }
+  }
+
+  /** Save (create or update) entity */
+  async save(c, entity, argsJson = "{}") {
+    if (!entity) {
+      console.error("Error: entity name required");
+      console.error("Usage: invokej dzql.save <entity> '<json_args>'");
+      console.error(
+        'Example: invokej dzql.save venues \'{"name": "Test Venue", "org_id": 1}\'',
+      );
+      await sql.end();
+      process.exit(1);
+    }
+
+    let args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      console.error("Error: arguments must be valid JSON");
+      await sql.end();
+      process.exit(1);
+    }
+
+    try {
+      const result = await db.api.save[entity](args, this.userId);
+      console.log(JSON.stringify({ success: true, result }, null, 2));
+      await sql.end();
+    } catch (error) {
+      console.error(
+        JSON.stringify({ success: false, error: error.message }, null, 2),
+      );
+      await sql.end();
+      process.exit(1);
+    }
+  }
+
+  /** Delete entity by ID */
+  async delete(c, entity, argsJson = "{}") {
+    if (!entity) {
+      console.error("Error: entity name required");
+      console.error("Usage: invokej dzql.delete <entity> '<json_args>'");
+      console.error("Example: invokej dzql.delete venues '{\"id\": 1}'");
+      await sql.end();
+      process.exit(1);
+    }
+
+    let args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      console.error("Error: arguments must be valid JSON");
+      await sql.end();
+      process.exit(1);
+    }
+
+    try {
+      const result = await db.api.delete[entity](args, this.userId);
+      console.log(JSON.stringify({ success: true, result }, null, 2));
+      await sql.end();
+    } catch (error) {
+      console.error(
+        JSON.stringify({ success: false, error: error.message }, null, 2),
+      );
+      await sql.end();
+      process.exit(1);
+    }
+  }
+
+  /** Lookup entity (for dropdowns/autocomplete) */
+  async lookup(c, entity, argsJson = "{}") {
+    if (!entity) {
+      console.error("Error: entity name required");
+      console.error("Usage: invokej dzql.lookup <entity> '<json_args>'");
+      console.error(
+        'Example: invokej dzql.lookup organisations \'{"query": "acme"}\'',
+      );
+      await sql.end();
+      process.exit(1);
+    }
+
+    let args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      console.error("Error: arguments must be valid JSON");
+      await sql.end();
+      process.exit(1);
+    }
+
+    try {
+      const result = await db.api.lookup[entity](args, this.userId);
+      console.log(JSON.stringify({ success: true, result }, null, 2));
+      await sql.end();
+    } catch (error) {
+      console.error(
+        JSON.stringify({ success: false, error: error.message }, null, 2),
+      );
+      await sql.end();
+      process.exit(1);
+    }
+  }
+}