dzql 0.5.33 → 0.6.1

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

@@ -1,290 +0,0 @@
-/**
- * Permission/Notification Path Parser
- * Parses DZQL path DSL into AST for code generation
- *
- * Path Grammar:
- * - Direct field: @field_name
- * - FK traversal: @field->table.target_field
- * - Conditional: @field->table[condition]{temporal}.target_field
- * - Complex: field1.field2->table[filter].target
- */
-
-export class PathParser {
-  /**
-   * Parse a permission/notification path into an AST
-   * @param {string} path - Path string to parse
-   * @returns {Object} AST representation
-   */
-  parse(path) {
-    if (!path || path.trim() === '') {
-      return { type: 'empty' };
-    }
-
-    // Direct field reference: @owner_id
-    if (path.match(/^@\w+$/)) {
-      return {
-        type: 'direct_field',
-        field: path.substring(1)
-      };
-    }
-
-    // Complex path with traversal
-    if (path.includes('->')) {
-      return this._parseTraversalPath(path);
-    }
-
-    // Field path with dot notation: field1.field2
-    if (path.includes('.') && !path.includes('->')) {
-      return this._parseDotPath(path);
-    }
-
-    // Unknown format
-    return {
-      type: 'unknown',
-      path
-    };
-  }
-
-  /**
-   * Parse a traversal path (contains ->)
-   * @private
-   */
-  _parseTraversalPath(path) {
-    const steps = [];
-    const parts = path.split('->');
-
-    for (let i = 0; i < parts.length; i++) {
-      const part = parts[i].trim();
-
-      if (i === 0) {
-        // First part: source field(s)
-        steps.push(this._parseSourceField(part));
-      } else if (i === parts.length - 1) {
-        // Last part: target field
-        steps.push(this._parseTargetField(part));
-      } else {
-        // Middle part: table with optional condition
-        steps.push(this._parseTableReference(part));
-      }
-    }
-
-    return {
-      type: 'traversal',
-      steps
-    };
-  }
-
-  /**
-   * Parse source field (can be @field or field.subfield)
-   * @private
-   */
-  _parseSourceField(part) {
-    if (part.startsWith('@')) {
-      return {
-        type: 'field_ref',
-        field: part.substring(1)
-      };
-    }
-
-    if (part.includes('.')) {
-      const fields = part.split('.');
-      return {
-        type: 'dot_path',
-        fields
-      };
-    }
-
-    return {
-      type: 'field_ref',
-      field: part
-    };
-  }
-
-  /**
-   * Parse table reference with optional filter and temporal marker
-   * Example: acts_for[org_id=$,role='admin']{active}
-   * @private
-   */
-  _parseTableReference(part) {
-    const result = {
-      type: 'table_ref',
-      table: null,
-      filter: null,
-      temporal: false,
-      targetField: null
-    };
-
-    // Extract temporal marker {active}
-    if (part.includes('{active}')) {
-      result.temporal = true;
-      part = part.replace('{active}', '');
-    }
-
-    // Extract filter [condition]
-    const filterMatch = part.match(/([a-z_]+)\[(.*?)\](\.(.+))?/i);
-    if (filterMatch) {
-      result.table = filterMatch[1];
-      result.filter = this._parseFilter(filterMatch[2]);
-      result.targetField = filterMatch[4] || null;
-      return result;
-    }
-
-    // Simple table.field reference
-    const dotMatch = part.match(/([a-z_]+)\.(.+)/i);
-    if (dotMatch) {
-      result.table = dotMatch[1];
-      result.targetField = dotMatch[2];
-      return result;
-    }
-
-    // Just table name
-    result.table = part;
-    return result;
-  }
-
-  /**
-   * Parse filter conditions
-   * Example: org_id=$,role='admin'
-   * @private
-   */
-  _parseFilter(filterStr) {
-    const conditions = [];
-    const parts = filterStr.split(',');
-
-    for (const part of parts) {
-      const trimmed = part.trim();
-
-      // Handle various comparison operators
-      if (trimmed.includes('=')) {
-        const [field, value] = trimmed.split('=').map(s => s.trim());
-        conditions.push({
-          field,
-          operator: '=',
-          value: value === '$' ? { type: 'param' } : this._parseValue(value)
-        });
-      }
-    }
-
-    return conditions;
-  }
-
-  /**
-   * Parse a value (string literal, number, param reference)
-   * @private
-   */
-  _parseValue(value) {
-    // String literal
-    if (value.startsWith("'") && value.endsWith("'")) {
-      return {
-        type: 'literal',
-        value: value.slice(1, -1)
-      };
-    }
-
-    // Number
-    if (/^\d+$/.test(value)) {
-      return {
-        type: 'number',
-        value: parseInt(value)
-      };
-    }
-
-    // Field reference
-    if (value.startsWith('@')) {
-      return {
-        type: 'field',
-        value: value.substring(1)
-      };
-    }
-
-    return {
-      type: 'literal',
-      value
-    };
-  }
-
-  /**
-   * Parse target field (last part of path)
-   * Example: user_id or users.user_id
-   * @private
-   */
-  _parseTargetField(part) {
-    // Check for temporal marker before removing it
-    const hasTemporal = part.includes('{active}');
-
-    // Remove temporal marker if present
-    part = part.replace('{active}', '');
-
-    // Check for table[filter].field pattern
-    const filterMatch = part.match(/([a-z_]+)\[(.*?)\]\.(.+)/i);
-    if (filterMatch) {
-      return {
-        type: 'table_ref',
-        table: filterMatch[1],
-        filter: this._parseFilter(filterMatch[2]),
-        temporal: hasTemporal,
-        targetField: filterMatch[3]
-      };
-    }
-
-    // Simple field reference
-    if (!part.includes('.')) {
-      return {
-        type: 'field_ref',
-        field: part
-      };
-    }
-
-    // Dot notation
-    const fields = part.split('.');
-    return {
-      type: 'dot_path',
-      fields
-    };
-  }
-
-  /**
-   * Parse dot path (field.subfield.subsubfield)
-   * @private
-   */
-  _parseDotPath(path) {
-    const fields = path.split('.').map(f => f.trim());
-    return {
-      type: 'dot_path',
-      fields
-    };
-  }
-
-  /**
-   * Parse multiple paths (used in permission arrays)
-   * @param {Array<string>} paths - Array of path strings
-   * @returns {Array<Object>} Array of ASTs
-   */
-  parseMultiple(paths) {
-    if (!Array.isArray(paths)) {
-      return [];
-    }
-
-    return paths.map(path => this.parse(path));
-  }
-}
-
-/**
- * Utility function to parse a single path
- * @param {string} path - Path to parse
- * @returns {Object} AST
- */
-export function parsePath(path) {
-  const parser = new PathParser();
-  return parser.parse(path);
-}
-
-/**
- * Utility function to parse multiple paths
- * @param {Array<string>} paths - Paths to parse
- * @returns {Array<Object>} ASTs
- */
-export function parsePaths(paths) {
-  const parser = new PathParser();
-  return parser.parseMultiple(paths);
-}

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

@@ -1,244 +0,0 @@
-/**
- * Subscribable Definition Parser
- * Parses register_subscribable() calls and extracts configuration
- */
-
-export class SubscribableParser {
-  /**
-   * Parse a dzql.register_subscribable() call from SQL
-   * @param {string} sql - SQL containing register_subscribable call
-   * @returns {Object} Parsed subscribable configuration
-   */
-  parseFromSQL(sql) {
-    // Extract the register_subscribable call
-    const registerMatch = sql.match(/dzql\.register_subscribable\s*\(([\s\S]*?)\);/i);
-    if (!registerMatch) {
-      throw new Error('No register_subscribable call found in SQL');
-    }
-
-    const params = this._parseParameters(registerMatch[1]);
-
-    return this._buildSubscribableConfig(params);
-  }
-
-  /**
-   * Parse parameters from register_subscribable call
-   * @private
-   */
-  _parseParameters(paramsString) {
-    // Split by commas that are not inside quotes, parentheses, or brackets
-    const params = [];
-    let currentParam = '';
-    let depth = 0;
-    let inString = false;
-    let stringChar = null;
-
-    for (let i = 0; i < paramsString.length; i++) {
-      const char = paramsString[i];
-      const prevChar = i > 0 ? paramsString[i - 1] : '';
-
-      if ((char === "'" || char === '"') && prevChar !== '\\') {
-        if (!inString) {
-          inString = true;
-          stringChar = char;
-        } else if (char === stringChar) {
-          inString = false;
-          stringChar = null;
-        }
-      }
-
-      if (!inString) {
-        if (char === '(' || char === '{' || char === '[') depth++;
-        if (char === ')' || char === '}' || char === ']') depth--;
-
-        if (char === ',' && depth === 0) {
-          params.push(currentParam.trim());
-          currentParam = '';
-          continue;
-        }
-      }
-
-      currentParam += char;
-    }
-
-    if (currentParam.trim()) {
-      params.push(currentParam.trim());
-    }
-
-    return params;
-  }
-
-  /**
-   * Build subscribable configuration from parsed parameters
-   * register_subscribable(name, permission_paths, param_schema, root_entity, relations)
-   * @private
-   */
-  _buildSubscribableConfig(params) {
-    const config = {
-      name: this._cleanString(params[0]),
-      permissionPaths: params[1] ? this._parseJSON(params[1]) : {},
-      paramSchema: params[2] ? this._parseJSON(params[2]) : {},
-      rootEntity: this._cleanString(params[3]),
-      relations: params[4] ? this._parseJSON(params[4]) : {}
-    };
-
-    return config;
-  }
-
-  /**
-   * Parse from JavaScript object (for programmatic usage)
-   * @param {Object} obj - Subscribable configuration object
-   * @returns {Object} Normalized configuration
-   */
-  parseFromObject(obj) {
-    return {
-      name: obj.name,
-      permissionPaths: obj.permissionPaths || obj.permissions || {},
-      paramSchema: obj.paramSchema || obj.params || {},
-      rootEntity: obj.rootEntity || obj.root,
-      relations: obj.relations || {}
-    };
-  }
-
-  /**
-   * Parse multiple subscribables from SQL file
-   * @param {string} sql - SQL file content
-   * @returns {Array} Array of subscribable configurations
-   */
-  parseAllFromSQL(sql) {
-    const subscribables = [];
-    const regex = /dzql\.register_subscribable\s*\(([\s\S]*?)\);/gi;
-    let match;
-
-    while ((match = regex.exec(sql)) !== null) {
-      try {
-        const params = this._parseParameters(match[1]);
-        const config = this._buildSubscribableConfig(params);
-        subscribables.push(config);
-      } catch (error) {
-        console.error('Failed to parse subscribable:', error.message);
-      }
-    }
-
-    return subscribables;
-  }
-
-  /**
-   * Clean a string parameter (remove quotes)
-   * @private
-   */
-  _cleanString(str) {
-    if (!str) return '';
-    // Handle SQL NULL keyword - return empty string for null values
-    if (str.trim().toUpperCase() === 'NULL') return '';
-    // Remove outer quotes, SQL comments, then any remaining quotes and whitespace
-    let cleaned = str.replace(/^['"]|['"]$/g, '');  // Remove outer quotes
-    cleaned = cleaned.replace(/--[^\n]*/g, '');     // Remove SQL comments
-    cleaned = cleaned.replace(/['"\s]+$/g, '');     // Remove trailing quotes/whitespace
-    return cleaned.trim();
-  }
-
-  /**
-   * Parse JSONB object parameter
-   * @private
-   */
-  _parseJSON(str) {
-    if (!str || str === '{}' || str === "'{}'::jsonb") {
-      return {};
-    }
-
-    // Handle jsonb_build_object() syntax
-    if (str.includes('jsonb_build_object')) {
-      return this._parseJSONBuildObject(str);
-    }
-
-    // Handle plain JSON string
-    try {
-      // Remove ::jsonb cast
-      let cleaned = str.replace(/::jsonb$/i, '');
-      // Remove outer quotes if it's a string literal (handles multi-line with [\s\S])
-      cleaned = cleaned.replace(/^'([\s\S]*)'$/, '$1');
-      // Unescape internal quotes
-      cleaned = cleaned.replace(/''/g, "'");
-
-      return JSON.parse(cleaned);
-    } catch (error) {
-      console.error('Failed to parse JSON:', str, error);
-      return {};
-    }
-  }
-
-  /**
-   * Parse jsonb_build_object() calls
-   * @private
-   */
-  _parseJSONBuildObject(str) {
-    const result = {};
-
-    // Extract content between jsonb_build_object( and )
-    const match = str.match(/jsonb_build_object\s*\(([\s\S]*)\)/i);
-    if (!match) return result;
-
-    // Parse key-value pairs
-    const params = this._parseParameters(match[1]);
-
-    for (let i = 0; i < params.length; i += 2) {
-      if (i + 1 < params.length) {
-        const key = this._cleanString(params[i]);
-        let value = params[i + 1];
-
-        // Check if value is nested jsonb_build_object or array
-        if (value.includes('jsonb_build_object')) {
-          value = this._parseJSONBuildObject(value);
-        } else if (value.includes('jsonb_build_array')) {
-          value = this._parseJSONBArray(value);
-        } else if (value.includes('ARRAY[')) {
-          value = this._parseArray(value);
-        } else {
-          value = this._cleanString(value);
-        }
-
-        result[key] = value;
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * Parse jsonb_build_array() calls
-   * @private
-   */
-  _parseJSONBArray(str) {
-    const match = str.match(/jsonb_build_array\s*\(([\s\S]*)\)/i);
-    if (!match) return [];
-
-    const params = this._parseParameters(match[1]);
-    return params.map(p => {
-      if (p.includes('jsonb_build_object')) {
-        return this._parseJSONBuildObject(p);
-      }
-      return this._cleanString(p);
-    });
-  }
-
-  /**
-   * Parse ARRAY[...] syntax
-   * @private
-   */
-  _parseArray(str) {
-    if (!str || str === 'ARRAY[]::text[]') {
-      return [];
-    }
-
-    // Extract content between ARRAY[ and ]
-    const match = str.match(/ARRAY\[(.*?)\]/i);
-    if (!match) return [];
-
-    // Split by comma and clean each element
-    return match[1]
-      .split(',')
-      .map(s => this._cleanString(s))
-      .filter(s => s.length > 0);
-  }
-}

package/src/database/dzql-core.sql

@@ -1,161 +0,0 @@
--- ============================================================================
--- DZQL Core - Minimal Foundation
--- ============================================================================
--- This is the minimal SQL needed for DZQL compiled mode.
--- Run: dzql db:init
--- Or:  psql $DATABASE_URL -f dzql-core.sql
--- ============================================================================
-
-CREATE EXTENSION IF NOT EXISTS pgcrypto;
-
-CREATE SCHEMA IF NOT EXISTS dzql;
-
--- Version tracking
-CREATE TABLE IF NOT EXISTS dzql.meta (
-  installed_at TIMESTAMPTZ DEFAULT now(),
-  version TEXT NOT NULL
-);
-
-INSERT INTO dzql.meta (version)
-SELECT '0.5.14'
-WHERE NOT EXISTS (SELECT 1 FROM dzql.meta);
-
--- Entity registry
-CREATE TABLE IF NOT EXISTS dzql.entities (
-  table_name TEXT PRIMARY KEY,
-  label_field TEXT NOT NULL,
-  searchable_fields TEXT[] NOT NULL,
-  fk_includes JSONB DEFAULT '{}',
-  soft_delete BOOLEAN DEFAULT false,
-  temporal_fields JSONB DEFAULT '{}',
-  notification_paths JSONB DEFAULT '{}',
-  permission_paths JSONB DEFAULT '{}',
-  graph_rules JSONB DEFAULT '{}',
-  field_defaults JSONB DEFAULT '{}',
-  many_to_many JSONB DEFAULT '{}'
-);
-
--- Function allowlist
-CREATE TABLE IF NOT EXISTS dzql.registry (
-  fn_regproc REGPROC PRIMARY KEY,
-  description TEXT
-);
-
--- Event audit table
-CREATE TABLE IF NOT EXISTS dzql.events (
-  event_id BIGSERIAL PRIMARY KEY,
-  table_name TEXT NOT NULL,
-  op TEXT NOT NULL,
-  pk JSONB NOT NULL,
-  data JSONB,
-  user_id INT,
-  notify_users INT[],
-  at TIMESTAMPTZ DEFAULT now()
-);
-
-CREATE INDEX IF NOT EXISTS dzql_events_at_idx ON dzql.events (at);
-CREATE INDEX IF NOT EXISTS dzql_events_table_pk_idx ON dzql.events (table_name, pk, at);
-
--- NOTIFY trigger for real-time updates
-CREATE OR REPLACE FUNCTION dzql.notify_event()
-RETURNS TRIGGER LANGUAGE plpgsql AS $$
-BEGIN
-  PERFORM pg_notify('dzql', jsonb_build_object(
-    'event_id', NEW.event_id,
-    'table', NEW.table_name,
-    'op', NEW.op,
-    'pk', NEW.pk,
-    'data', NEW.data,
-    'user_id', NEW.user_id,
-    'at', NEW.at,
-    'notify_users', NEW.notify_users
-  )::text);
-  RETURN NULL;
-END $$;
-
-DROP TRIGGER IF EXISTS dzql_events_notify ON dzql.events;
-CREATE TRIGGER dzql_events_notify
-  AFTER INSERT ON dzql.events
-  FOR EACH ROW EXECUTE FUNCTION dzql.notify_event();
-
--- Subscribables registry (for compiled subscribables)
-CREATE TABLE IF NOT EXISTS dzql.subscribables (
-  name TEXT PRIMARY KEY,
-  permission_paths JSONB DEFAULT '{}',
-  param_schema JSONB DEFAULT '{}',
-  root_entity TEXT NOT NULL,
-  relations JSONB DEFAULT '{}',
-  scope_tables TEXT[] DEFAULT '{}',
-  created_at TIMESTAMPTZ DEFAULT now()
-);
-
--- Helper to register entities
-CREATE OR REPLACE FUNCTION dzql.register_entity(
-  p_table_name TEXT,
-  p_label_field TEXT,
-  p_searchable_fields TEXT[],
-  p_fk_includes JSONB DEFAULT '{}',
-  p_soft_delete BOOLEAN DEFAULT false,
-  p_temporal_fields JSONB DEFAULT '{}',
-  p_notification_paths JSONB DEFAULT '{}',
-  p_permission_paths JSONB DEFAULT '{}',
-  p_graph_rules JSONB DEFAULT '{}',
-  p_field_defaults JSONB DEFAULT '{}',
-  p_many_to_many JSONB DEFAULT '{}'
-) RETURNS VOID AS $$
-BEGIN
-  INSERT INTO dzql.entities (
-    table_name, label_field, searchable_fields, fk_includes,
-    soft_delete, temporal_fields, notification_paths, permission_paths,
-    graph_rules, field_defaults, many_to_many
-  ) VALUES (
-    p_table_name, p_label_field, p_searchable_fields, p_fk_includes,
-    p_soft_delete, p_temporal_fields, p_notification_paths, p_permission_paths,
-    p_graph_rules, p_field_defaults, p_many_to_many
-  )
-  ON CONFLICT (table_name) DO UPDATE SET
-    label_field = EXCLUDED.label_field,
-    searchable_fields = EXCLUDED.searchable_fields,
-    fk_includes = EXCLUDED.fk_includes,
-    soft_delete = EXCLUDED.soft_delete,
-    temporal_fields = EXCLUDED.temporal_fields,
-    notification_paths = EXCLUDED.notification_paths,
-    permission_paths = EXCLUDED.permission_paths,
-    graph_rules = EXCLUDED.graph_rules,
-    field_defaults = EXCLUDED.field_defaults,
-    many_to_many = EXCLUDED.many_to_many;
-END;
-$$ LANGUAGE plpgsql;
-
--- Helper to register subscribables
-CREATE OR REPLACE FUNCTION dzql.register_subscribable(
-  p_name TEXT,
-  p_permission_paths JSONB,
-  p_param_schema JSONB,
-  p_root_entity TEXT,
-  p_relations JSONB DEFAULT '{}'
-) RETURNS VOID AS $$
-DECLARE
-  v_scope_tables TEXT[];
-BEGIN
-  -- Extract scope tables from relations
-  SELECT array_agg(DISTINCT tbl) INTO v_scope_tables
-  FROM (
-    SELECT p_root_entity AS tbl
-    UNION ALL
-    SELECT value->>'entity' AS tbl
-    FROM jsonb_each(p_relations)
-    WHERE value->>'entity' IS NOT NULL
-  ) t
-  WHERE tbl IS NOT NULL;
-
-  INSERT INTO dzql.subscribables (name, permission_paths, param_schema, root_entity, relations, scope_tables)
-  VALUES (p_name, p_permission_paths, p_param_schema, p_root_entity, p_relations, v_scope_tables)
-  ON CONFLICT (name) DO UPDATE SET
-    permission_paths = EXCLUDED.permission_paths,
-    param_schema = EXCLUDED.param_schema,
-    root_entity = EXCLUDED.root_entity,
-    relations = EXCLUDED.relations,
-    scope_tables = EXCLUDED.scope_tables;
-END;
-$$ LANGUAGE plpgsql;