@soulbatical/tetra-core 0.1.13 → 0.1.15

package/dist/generators/rpc/rpc-generator.js

@@ -0,0 +1,743 @@
+/**
+ * RPC Generator
+ * Auto-generates SQL RPC functions from FeatureConfig
+ *
+ * This is the core of the SQL Generator system. It takes a FeatureConfig
+ * and generates two SQL migration files:
+ * 1. get_<table>_results.sql - Results function (paginated, with includes)
+ * 2. get_<table>_counts.sql - Counts function (filter breakdowns)
+ *
+ * Usage:
+ * const generator = new RPCGenerator(ordersFeatureConfig);
+ * const { resultsSQL, countsSQL } = generator.generate();
+ * generator.writeMigrations();
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { generateTimestamp, getTableAlias, escapeIdentifier } from './utils.js';
+import { validateConfig } from './validator.js';
+// Import filter templates
+import { generateEnumWhere, generateEnumCounts } from './templates/enum.js';
+import { generateColumnWhere, generateColumnCounts } from './templates/column.js';
+import { generateNullableWhere, generateNullableCounts } from './templates/nullable.js';
+import { generateRelatedWhere, generateRelatedCounts } from './templates/related.js';
+import { generateTimeWhere, generateTimeCounts } from './templates/time.js';
+import { generateSearchWhere, generateSearchCounts } from './templates/search.js';
+import { generateArrayWhere, generateArrayCounts } from './templates/array.js';
+// Security template (v3.9 → v3.15: Service role + anon blocking + session_user fix)
+import { generateAuthCheck, generateAuthWhereClause, generateAuthDeclarations } from './templates/auth.js';
+export class RPCGenerator {
+    config;
+    tableName;
+    tableAlias;
+    aliasMap;
+    userIdColumn;
+    searchJoins;
+    GENERATOR_VERSION = '3.17'; // v3.17: Document public. prefix requirement for customWhereClause/sqlComputedFields (January 16, 2026)
+    ENABLE_RPC_INCLUDES = true; // Enabled - LATERAL JOINs for selective includes (pagination limits dataset!)
+    constructor(config, options) {
+        // Validate config first
+        const validation = validateConfig(config);
+        if (!validation.valid) {
+            throw new Error(`Invalid feature config:\n${this.formatValidationErrors(validation)}`);
+        }
+        this.config = config;
+        this.tableName = config.tableName;
+        this.aliasMap = options?.aliasMap;
+        this.tableAlias = getTableAlias(this.tableName, this.aliasMap);
+        this.userIdColumn = options?.userIdColumn || 'user_id';
+        this.searchJoins = options?.searchJoins || {
+            user: (alias) => `LEFT JOIN public.users_public u ON u.id = ${alias}.${this.userIdColumn}`,
+            order: (alias) => `LEFT JOIN public.orders o ON o.id = ${alias}.order_id`,
+        };
+        // Log warnings
+        if (validation.warnings.length > 0) {
+            console.warn('Warning: Validation warnings:');
+            validation.warnings.forEach(w => {
+                console.warn(`   ${w.field}: ${w.message}`);
+                if (w.suggestion)
+                    console.warn(`   Suggestion: ${w.suggestion}`);
+            });
+        }
+    }
+    /**
+     * Format validation errors for display
+     */
+    formatValidationErrors(validation) {
+        const errors = validation.errors.map(e => `  - ${e.field}: ${e.message}${e.suggestion ? `\n    Suggestion: ${e.suggestion}` : ''}`);
+        return errors.join('\n');
+    }
+    /**
+     * Parse filters from config
+     */
+    parseFilters() {
+        if (!this.config.filters)
+            return [];
+        return this.config.filters.map(filter => ({
+            ...filter,
+            paramName: `p_${filter.rpcParam || filter.name}`,
+            paramType: this.getParamType(filter)
+        }));
+    }
+    /**
+     * Get SQL parameter type for filter
+     */
+    getParamType(filter) {
+        switch (filter.type) {
+            case 'multiselect':
+                return 'text[]'; // Array for multiselect
+            case 'daterange':
+                return 'daterange'; // PostgreSQL daterange type
+            case 'array':
+                // Support custom array type via sqlGeneration.arrayType (e.g., 'text[]' for varchar columns)
+                return filter.sqlGeneration?.arrayType || 'uuid[]'; // Default: UUID[] for by-ids navigation
+            default:
+                return 'text'; // Most filters use text
+        }
+    }
+    /**
+     * Generate filter function signature
+     */
+    generateFilterSignature() {
+        const params = [
+            `p_org_id uuid`
+        ];
+        // Add all filter parameters
+        this.parseFilters().forEach(filter => {
+            params.push(`${filter.paramName} ${filter.paramType} DEFAULT NULL`);
+        });
+        // Add sort parameter
+        params.push(`p_sort_by text DEFAULT 'date-desc'`);
+        // Use filterRpcName if specified, otherwise generate from tableName
+        if (this.config.filterRpcName) {
+            return `${this.config.filterRpcName}(\n  ${params.join(',\n  ')}\n)`;
+        }
+        return `filter_${this.config.tableName}_simple(\n  ${params.join(',\n  ')}\n)`;
+    }
+    /**
+     * Generate org WHERE clause (includes system content where organization_id IS NULL)
+     */
+    generateOrgWhereClause(alias) {
+        const f = `${alias}.${this.config.organizationIdField}`;
+        return `(p_org_id IS NULL OR ${f} = p_org_id OR ${f} IS NULL)`;
+    }
+    /**
+     * Generate WHERE clause for a filter
+     */
+    generateWhereClause(filter) {
+        // Check for custom WHERE clause
+        if (filter.sqlGeneration?.customWhereClause) {
+            return `\n      -- ${filter.name} (custom WHERE clause)\n      AND ${filter.sqlGeneration.customWhereClause}`;
+        }
+        // Use template based on filter type
+        switch (filter.type) {
+            case 'enum':
+                return generateEnumWhere(filter, this.tableName, this.aliasMap);
+            case 'column':
+                return generateColumnWhere(filter, this.tableName, this.aliasMap);
+            case 'nullable':
+                return generateNullableWhere(filter, this.tableName, this.aliasMap);
+            case 'related':
+                return generateRelatedWhere(filter, this.tableName, this.aliasMap);
+            case 'time':
+                return generateTimeWhere(filter, this.tableName, this.aliasMap);
+            case 'search':
+                return generateSearchWhere(filter, this.tableName, this.aliasMap);
+            case 'array':
+                return generateArrayWhere(filter, this.tableName, this.aliasMap);
+            default:
+                throw new Error(`Unsupported filter type: ${filter.type}`);
+        }
+    }
+    /**
+     * Generate all WHERE clauses
+     */
+    generateWhereClauses() {
+        const filters = this.parseFilters();
+        if (filters.length === 0) {
+            return '';
+        }
+        return filters.map(filter => this.generateWhereClause(filter)).join('\n');
+    }
+    /**
+     * Generate ORDER BY clause
+     */
+    generateOrderBy() {
+        const alias = this.tableAlias;
+        const defaultSortField = this.config.defaultSortField || 'created_at';
+        const allowedSortFields = this.config.allowedSortFields || [defaultSortField];
+        // Use sortFields config to find the field for 'name' alias
+        let nameField = null;
+        let hasNameSort = false;
+        if (this.config.sortFields) {
+            // Find the sortField with alias: 'name'
+            const nameSortConfig = this.config.sortFields.find(sf => sf.alias === 'name');
+            if (nameSortConfig) {
+                nameField = nameSortConfig.field;
+                hasNameSort = true;
+            }
+        }
+        // If no sortFields config, fall back to old logic (auto-detect name field)
+        if (!this.config.sortFields) {
+            const detectedNameField = allowedSortFields.find(f => ['firstname', 'lastname', 'name', 'title', 'original_filename', 'filename'].includes(f.toLowerCase()));
+            if (detectedNameField) {
+                nameField = detectedNameField;
+                hasNameSort = true;
+            }
+        }
+        // Build CASE statements for each sort option
+        let orderBy = `
+    ORDER BY
+      CASE WHEN p_sort_by = 'date-desc' THEN ${alias}.${escapeIdentifier(defaultSortField)} END DESC NULLS LAST,
+      CASE WHEN p_sort_by = 'date-asc' THEN ${alias}.${escapeIdentifier(defaultSortField)} END ASC NULLS LAST,`;
+        // Only add name sorting if we have a valid name field
+        if (hasNameSort && nameField) {
+            const nameSortExpr = `LOWER(${alias}.${escapeIdentifier(nameField)})`;
+            orderBy += `
+      CASE WHEN p_sort_by = 'name-asc' THEN ${nameSortExpr} END ASC NULLS LAST,
+      CASE WHEN p_sort_by = 'name-desc' THEN ${nameSortExpr} END DESC NULLS LAST,`;
+        }
+        orderBy += `
+      ${alias}.${escapeIdentifier(defaultSortField)} DESC  -- Fallback`;
+        return orderBy;
+    }
+    /**
+     * Detect required JOINs from searchFields
+     * v3.11: Add public. prefix for Postgres v17 compatibility
+     * v3.14: Also check filter-level searchFields (filter.sqlGeneration.searchFields)
+     */
+    detectJoins() {
+        // Collect searchFields from both root config and filter configs
+        const allSearchFields = [...(this.config.searchFields || [])];
+        // v3.14: Also check filter-level searchFields
+        if (this.config.filters) {
+            this.config.filters.forEach(filter => {
+                if (filter.type === 'search' && filter.sqlGeneration?.searchFields) {
+                    allSearchFields.push(...filter.sqlGeneration.searchFields);
+                }
+            });
+        }
+        const joinSet = new Set();
+        allSearchFields.forEach(field => {
+            if (field.includes('.')) {
+                const [relation] = field.split('.');
+                const joinFn = this.searchJoins[relation];
+                if (joinFn) {
+                    joinSet.add(joinFn(this.tableAlias));
+                }
+            }
+        });
+        return joinSet.size > 0 ? '\n    ' + Array.from(joinSet).join('\n    ') : '';
+    }
+    /**
+     * Generate complete filter function SQL
+     */
+    generateFilterFunction() {
+        const signature = this.generateFilterSignature();
+        const whereClauses = this.generateWhereClauses();
+        const orderBy = this.generateOrderBy();
+        const alias = this.tableAlias;
+        const joins = this.detectJoins();
+        // v3.11: Add public. prefix for Postgres v17 compatibility (empty search_path)
+        return `-- ============================================================================
+-- Filter function for ${this.tableName}
+-- ============================================================================
+-- DO NOT EDIT MANUALLY! This file is auto-generated.
+--     Changes will be OVERWRITTEN on next generation.
+--
+-- To modify this function:
+--   1. Edit config: /backend/src/features/${this.tableName}/config/${this.tableName}.config.ts
+--   2. Regenerate:  npm run generate:rpc ${this.tableName}
+--   3. Apply:       Use MCP apply_migration or supabase db push
+--
+-- Generator: SQL Generator v${this.GENERATOR_VERSION}
+-- Generated: ${new Date().toISOString()}
+-- ============================================================================
+
+DROP FUNCTION IF EXISTS public.${signature.split('(')[0]};
+
+CREATE OR REPLACE FUNCTION public.${signature}
+RETURNS uuid[]
+LANGUAGE plpgsql
+STABLE
+AS $$
+BEGIN
+  RETURN ARRAY(
+    SELECT ${alias}.id
+    FROM public.${this.tableName} ${alias}${joins}
+    WHERE ${this.generateOrgWhereClause(alias)}${whereClauses}
+${orderBy}
+  );
+END;
+$$;
+`;
+    }
+    /**
+     * Generate counts query for a filter
+     */
+    generateCountsQuery(filter) {
+        // Check for custom counts query
+        if (filter.sqlGeneration?.customCountsQuery) {
+            return filter.sqlGeneration.customCountsQuery;
+        }
+        // Search and array filters don't have counts
+        if (filter.type === 'search') {
+            return generateSearchCounts(filter);
+        }
+        if (filter.type === 'array') {
+            // Array filters (like 'ids') don't generate counts
+            return generateArrayCounts(filter) || '';
+        }
+        // Use template based on filter type
+        switch (filter.type) {
+            case 'enum':
+                return generateEnumCounts(filter);
+            case 'column':
+                return generateColumnCounts(filter);
+            case 'nullable':
+                return generateNullableCounts(filter);
+            case 'related':
+                return generateRelatedCounts(filter, this.tableName, this.aliasMap);
+            case 'time':
+                return generateTimeCounts(filter);
+            default:
+                return ''; // No counts for unsupported types
+        }
+    }
+    /**
+     * Generate all counts queries
+     */
+    generateCountsQueries() {
+        const filters = this.parseFilters();
+        const countsQueries = filters
+            .map(filter => this.generateCountsQuery(filter))
+            .filter(query => query !== '') // Remove empty queries (search filters)
+            .join(',\n');
+        return countsQueries;
+    }
+    /**
+     * Generate counts function signature
+     */
+    generateCountsSignature() {
+        const params = [
+            `p_org_id uuid DEFAULT NULL` // Optional for system-wide operations
+        ];
+        // Add all filter parameters (same as filter/results function)
+        this.parseFilters().forEach(filter => {
+            params.push(`${filter.paramName} ${filter.paramType} DEFAULT NULL`);
+        });
+        // NOTE: p_sort_by is NOT added to counts - counts don't need sorting!
+        // Only results function has p_sort_by parameter
+        // Use countsRpcName if specified, otherwise generate from tableName
+        const funcName = this.config.countsRpcName || `get_${this.config.tableName}_counts`;
+        return `${funcName}(\n  ${params.join(',\n  ')}\n)`;
+    }
+    /**
+     * Generate complete counts function SQL
+     */
+    generateCountsFunction() {
+        const signature = this.generateCountsSignature();
+        const whereClauses = this.generateWhereClauses();
+        const countsQueries = this.generateCountsQueries();
+        const alias = this.tableAlias;
+        const joins = this.detectJoins();
+        // v3.9 → v3.10: Generate auth check and WHERE clause based on accessLevel config
+        const accessLevel = (this.config.accessLevel || 'admin');
+        const authCheck = generateAuthCheck(accessLevel);
+        // v3.10: Generate auth WHERE clause for creator visibility filtering
+        // v3.11: Pass organizationIdField from config
+        const creatorVisibility = this.config.creatorVisibility;
+        const organizationIdField = this.config.organizationIdField || 'organization_id';
+        const authWhereClause = generateAuthWhereClause(accessLevel, alias, creatorVisibility, organizationIdField);
+        const securityNote = accessLevel === 'public' || accessLevel === 'system'
+            ? `-- Access Level: ${accessLevel} (no auth check)`
+            : accessLevel === 'creator' && creatorVisibility
+                ? `-- Access Level: ${accessLevel} (auth check + visibility: ${creatorVisibility.column})`
+                : `-- Access Level: ${accessLevel} (auth check enabled)`;
+        // Include joined table columns in CTE if we have joins
+        const selectClause = joins.includes('orders')
+            ? `${alias}.*, o.status as order_status, o.source as order_source`
+            : `${alias}.*`;
+        return `-- ============================================================================
+-- Counts function for ${this.tableName}
+-- ============================================================================
+-- DO NOT EDIT MANUALLY! This file is auto-generated.
+--     Changes will be OVERWRITTEN on next generation.
+--
+-- To modify this function:
+--   1. Edit config: /backend/src/features/${this.tableName}/config/${this.tableName}.config.ts
+--   2. Regenerate:  npm run generate:rpc ${this.tableName}
+--   3. Apply:       Use MCP apply_migration or supabase db push
+--
+-- Generator: SQL Generator v${this.GENERATOR_VERSION}
+-- Generated: ${new Date().toISOString()}
+-- ${securityNote}
+-- ============================================================================
+
+DROP FUNCTION IF EXISTS public.${signature.split('(')[0]}_simple;
+DROP FUNCTION IF EXISTS public.${signature.split('(')[0]};
+
+CREATE OR REPLACE FUNCTION public.${signature}
+RETURNS jsonb
+LANGUAGE plpgsql
+STABLE
+SECURITY DEFINER
+SET search_path = ''
+AS $$
+DECLARE
+  result jsonb;${generateAuthDeclarations(accessLevel)}
+BEGIN
+${authCheck}
+  -- Create filtered CTE for consistent counts
+  -- v3.11: Add public. prefix for Postgres v17 compatibility
+  WITH filtered_items AS (
+    SELECT ${selectClause}
+    FROM public.${this.tableName} ${alias}${joins}
+    WHERE ${this.generateOrgWhereClause(alias)}${whereClauses}
+      ${authWhereClause}
+  )
+  SELECT jsonb_build_object(
+    'total', (SELECT COUNT(*)::int FROM filtered_items),${countsQueries}
+  ) INTO result;
+
+  RETURN result;
+END;
+$$;
+`;
+    }
+    /**
+     * Generate JSONB aggregates for includes (v3.5)
+     * Returns LATERAL JOIN subqueries that aggregate related records as JSONB arrays
+     */
+    generateIncludeJoins() {
+        if (!this.ENABLE_RPC_INCLUDES) {
+            return '';
+        }
+        if (!this.config.includeMapping || Object.keys(this.config.includeMapping).length === 0) {
+            return '';
+        }
+        const joins = [];
+        const alias = this.tableAlias;
+        for (const [includeName, includeConfig] of Object.entries(this.config.includeMapping)) {
+            const includeAlias = includeName.substring(0, 3); // e.g., 'orders' → 'ord'
+            const fields = includeConfig.fields.map(f => `'${f}', ${includeAlias}.${f}`).join(', ');
+            // Check if this is a many-to-many relationship via junction table
+            // v3.11: Add public. prefix for Postgres v17 compatibility
+            if (includeConfig.junctionTable && includeConfig.junctionForeignKey && includeConfig.junctionTargetKey) {
+                // M:N relationship via junction table
+                const junctionAlias = 'j_' + includeAlias;
+                joins.push(`
+    LEFT JOIN LATERAL (
+      SELECT jsonb_agg(to_jsonb(${includeAlias}.*)) as ${includeName}_data
+      FROM public.${includeConfig.junctionTable} ${junctionAlias}
+      JOIN public.${includeConfig.tableName} ${includeAlias} ON ${includeAlias}.id = ${junctionAlias}.${includeConfig.junctionTargetKey}
+      WHERE ${junctionAlias}.${includeConfig.junctionForeignKey} = ${alias}.id
+    ) ${includeName}_agg ON true`);
+                continue;
+            }
+            // Get foreign key column - use explicit column if provided, otherwise auto-detect
+            const foreignKeyColumn = includeConfig.column || this.getForeignKeyColumn(includeConfig.foreignKey || '');
+            // Detect join direction: is this table referencing us (1:N) or are we referencing it (N:1)?
+            const isOneToMany = (includeConfig.foreignKey || '').includes(`${includeConfig.tableName}_`);
+            if (isOneToMany) {
+                // 1:N relationship
+                // Check for nested includes (v3.8, enhanced v3.9)
+                if (includeConfig.nested && Object.keys(includeConfig.nested).length > 0) {
+                    // Build nested JOINs and fields
+                    const nestedJoins = [];
+                    const nestedFields = [];
+                    let aliasCounter = 0;
+                    for (const [nestedName, nestedConfig] of Object.entries(includeConfig.nested)) {
+                        const nestedAlias = `n${aliasCounter++}`;
+                        const nestedFKColumn = nestedConfig.column || this.getForeignKeyColumn(nestedConfig.foreignKey || '');
+                        // v3.9: Use outputName if specified, otherwise use nestedName
+                        const outputName = nestedConfig.outputName || nestedName;
+                        // Add LEFT JOIN for nested relation (v3.11: public. prefix)
+                        nestedJoins.push(`LEFT JOIN public.${nestedConfig.tableName} ${nestedAlias} ON ${nestedAlias}.id = ${includeAlias}.${nestedFKColumn}`);
+                        // v3.9: Check for deepNested
+                        const deepNested = nestedConfig.deepNested;
+                        if (deepNested && Object.keys(deepNested).length > 0) {
+                            // Build deep nested JOINs and CASE expression
+                            const deepNestedParts = [];
+                            for (const [deepName, deepConfig] of Object.entries(deepNested)) {
+                                const deepAlias = `d${aliasCounter++}`;
+                                const deepOutputName = deepConfig.outputName || deepName;
+                                // Add deep JOIN (v3.11: public. prefix)
+                                nestedJoins.push(`LEFT JOIN public.${deepConfig.tableName} ${deepAlias} ON ${deepAlias}.id = ${nestedAlias}.${deepConfig.joinColumn}`);
+                                // Build deep nested object
+                                const deepFields = deepConfig.fields.map((f) => `'${f}', ${deepAlias}.${f}`).join(', ');
+                                deepNestedParts.push(`'${deepOutputName}', CASE WHEN ${deepAlias}.id IS NOT NULL THEN jsonb_build_object(${deepFields}) ELSE NULL END`);
+                            }
+                            // Build the nested object with deep nested data
+                            const nestedFieldsList = nestedConfig.fields.map(f => `'${f}', ${nestedAlias}.${f}`).join(', ');
+                            nestedFields.push(`'${outputName}', CASE WHEN ${nestedAlias}.id IS NOT NULL THEN jsonb_build_object(${nestedFieldsList}, ${deepNestedParts.join(', ')}) ELSE NULL END`);
+                        }
+                        else {
+                            // Simple nested object (no deep nesting)
+                            const nestedFieldsList = nestedConfig.fields.map(f => `'${f}', ${nestedAlias}.${f}`).join(', ');
+                            nestedFields.push(`'${outputName}', CASE WHEN ${nestedAlias}.id IS NOT NULL THEN jsonb_build_object(${nestedFieldsList}) ELSE NULL END`);
+                        }
+                    }
+                    // Combine base fields with nested fields
+                    const allFields = `${fields}, ${nestedFields.join(', ')}`;
+                    // v3.12: Use orderBy from config if specified
+                    const orderByClause = includeConfig.orderBy
+                        ? ` ORDER BY ${includeAlias}.${includeConfig.orderBy}`
+                        : '';
+                    // v3.11: Add public. prefix for Postgres v17 compatibility
+                    joins.push(`
+    LEFT JOIN LATERAL (
+      SELECT COALESCE(jsonb_agg(jsonb_build_object(${allFields})${orderByClause}), '[]'::jsonb) as ${includeName}_data
+      FROM public.${includeConfig.tableName} ${includeAlias}
+      ${nestedJoins.join('\n      ')}
+      WHERE ${includeAlias}.${foreignKeyColumn} = ${alias}.id
+    ) ${includeName}_agg ON true`);
+                }
+                else {
+                    // Simple 1:N without nesting (v3.11: public. prefix)
+                    joins.push(`
+    LEFT JOIN LATERAL (
+      SELECT COALESCE(jsonb_agg(jsonb_build_object(${fields})), '[]'::jsonb) as ${includeName}_data
+      FROM public.${includeConfig.tableName} ${includeAlias}
+      WHERE ${includeAlias}.${foreignKeyColumn} = ${alias}.id
+    ) ${includeName}_agg ON true`);
+                }
+            }
+            else {
+                // N:1 relationship
+                // v3.11: Add public. prefix for Postgres v17 compatibility
+                joins.push(`
+    LEFT JOIN LATERAL (
+      SELECT to_jsonb(${includeAlias}.*) as ${includeName}_data
+      FROM public.${includeConfig.tableName} ${includeAlias}
+      WHERE ${includeAlias}.id = ${alias}.${foreignKeyColumn}
+    ) ${includeName}_agg ON true`);
+            }
+        }
+        return joins.join('');
+    }
+    /**
+     * Extract column name from foreign key constraint name
+     * Example: 'orders_user_id_fkey' → 'user_id'
+     *          'users_public_active_organization_id_fkey' → 'active_organization_id'
+     */
+    getForeignKeyColumn(foreignKeyName) {
+        // Remove _fkey suffix first
+        let column = foreignKeyName.replace(/_fkey$/, '');
+        // Try removing related table name prefix
+        for (const [_includeName, includeConfig] of Object.entries(this.config.includeMapping || {})) {
+            const tablePrefix = includeConfig.tableName + '_';
+            if (column.startsWith(tablePrefix)) {
+                column = column.substring(tablePrefix.length);
+                return column;
+            }
+        }
+        // Try removing our table name prefix
+        const ourTablePrefix = this.config.tableName + '_';
+        if (column.startsWith(ourTablePrefix)) {
+            column = column.substring(ourTablePrefix.length);
+        }
+        return column;
+    }
+    /**
+     * Generate SELECT columns with includes as JSONB fields (v3.5)
+     */
+    generateIncludesCases() {
+        if (!this.ENABLE_RPC_INCLUDES) {
+            return '';
+        }
+        if (!this.config.includeMapping || Object.keys(this.config.includeMapping).length === 0) {
+            return '';
+        }
+        const cases = [];
+        for (const includeName of Object.keys(this.config.includeMapping)) {
+            cases.push(`${includeName}_agg.${includeName}_data as ${includeName}`);
+        }
+        return cases.join(',\n      ');
+    }
+    /**
+     * Generate all table columns for SELECT clause
+     */
+    generateTableColumns() {
+        return `${this.tableAlias}.*`;
+    }
+    /**
+     * Generate SQL computed fields (v3.8)
+     * Returns computed field expressions for SELECT clause
+     */
+    generateSQLComputedFields() {
+        if (!this.config.sqlComputedFields || this.config.sqlComputedFields.length === 0) {
+            return '';
+        }
+        const fields = this.config.sqlComputedFields.map(field => {
+            // Replace {alias} placeholder with actual table alias
+            const sql = field.sql.replace(/\{alias\}/g, this.tableAlias);
+            return `${sql} as ${field.name}`;
+        });
+        return fields.join(',\n      ');
+    }
+    /**
+     * Generate results function signature
+     */
+    generateResultsSignature() {
+        const params = [
+            `p_org_id uuid DEFAULT NULL` // Optional for system-wide cron jobs
+        ];
+        // Add all filter parameters
+        this.parseFilters().forEach(filter => {
+            params.push(`${filter.paramName} ${filter.paramType} DEFAULT NULL`);
+        });
+        // Add pagination parameters
+        params.push(`p_limit int DEFAULT 20`);
+        params.push(`p_offset int DEFAULT 0`);
+        params.push(`p_sort_by text DEFAULT 'date-desc'`);
+        const funcName = this.config.resultsRpcName || `get_${this.config.tableName}_results`;
+        return `${funcName}(\n  ${params.join(',\n  ')}\n)`;
+    }
+    /**
+     * Generate complete results function SQL (NEW - replaces filter + .in pattern!)
+     */
+    generateResultsFunction() {
+        const signature = this.generateResultsSignature();
+        const whereClauses = this.generateWhereClauses();
+        const orderBy = this.generateOrderBy();
+        const alias = this.tableAlias;
+        const searchJoins = this.detectJoins(); // JOINs for search
+        const includeJoins = this.generateIncludeJoins(); // JOINs for includes
+        const allJoins = searchJoins + includeJoins;
+        const tableColumns = this.generateTableColumns();
+        const includesCases = this.generateIncludesCases();
+        const computedFields = this.generateSQLComputedFields(); // v3.8: SQL computed fields
+        // v3.9 → v3.10: Generate auth check and WHERE clause based on accessLevel config
+        const accessLevel = (this.config.accessLevel || 'admin');
+        const authCheck = generateAuthCheck(accessLevel);
+        // v3.10: Generate auth WHERE clause for creator visibility filtering
+        const creatorVisibility = this.config.creatorVisibility;
+        const organizationIdField = this.config.organizationIdField || 'organization_id';
+        const authWhereClause = generateAuthWhereClause(accessLevel, alias, creatorVisibility, organizationIdField);
+        const securityNote = accessLevel === 'public' || accessLevel === 'system'
+            ? `-- Access Level: ${accessLevel} (no auth check)`
+            : accessLevel === 'creator' && creatorVisibility
+                ? `-- Access Level: ${accessLevel} (auth check + visibility: ${creatorVisibility.column})`
+                : `-- Access Level: ${accessLevel} (auth check enabled)`;
+        // Build SELECT clause with all parts
+        const selectParts = [tableColumns];
+        if (computedFields)
+            selectParts.push(computedFields);
+        if (includesCases)
+            selectParts.push(includesCases);
+        selectParts.push('COUNT(*) OVER() as total_count');
+        const selectClause = selectParts.join(',\n      ');
+        return `-- ============================================================================
+-- Results function for ${this.tableName}
+-- ============================================================================
+-- DO NOT EDIT MANUALLY! This file is auto-generated.
+--     Changes will be OVERWRITTEN on next generation.
+--
+-- To modify this function:
+--   1. Edit config: /backend/src/features/${this.tableName}/config/${this.tableName}.config.ts
+--   2. Regenerate:  npm run generate:rpc ${this.tableName}
+--   3. Apply:       Use MCP apply_migration or supabase db push
+--
+-- Generator: SQL Generator v${this.GENERATOR_VERSION} (Window Function Pattern with JSONB Includes)
+-- Generated: ${new Date().toISOString()}
+--
+-- Pattern: get_${this.tableName}_results() -> Returns full records + includes + total_count
+-- ${securityNote}
+-- ============================================================================
+
+DROP FUNCTION IF EXISTS public.${signature.split('(')[0]};
+
+CREATE OR REPLACE FUNCTION public.${signature}
+RETURNS TABLE (
+  data jsonb,
+  total_count bigint
+)
+LANGUAGE plpgsql
+STABLE
+SECURITY DEFINER
+SET search_path = ''
+AS $$${accessLevel !== 'public' && accessLevel !== 'system' ? `
+DECLARE${generateAuthDeclarations(accessLevel)}` : ''}
+BEGIN
+${authCheck}
+  RETURN QUERY
+  -- v3.11: Add public. prefix for Postgres v17 compatibility
+  WITH results AS (
+    SELECT
+      ${selectClause}
+    FROM public.${this.tableName} ${alias}${allJoins}
+    WHERE ${this.generateOrgWhereClause(alias)}${whereClauses}
+      ${authWhereClause}
+${orderBy}
+    LIMIT p_limit
+    OFFSET p_offset
+  )
+  SELECT
+    to_jsonb(results.*) - 'total_count' as data,
+    results.total_count
+  FROM results;
+END;
+$$;
+`;
+    }
+    /**
+     * Generate both results and counts functions (NEW API)
+     */
+    generate() {
+        return {
+            resultsSQL: this.generateResultsFunction(),
+            countsSQL: this.generateCountsFunction(),
+            filterSQL: this.generateFilterFunction() // For backwards compatibility
+        };
+    }
+    /**
+     * Write migrations to files (NEW - generates results + counts)
+     */
+    writeMigrations(options = {}) {
+        const { resultsSQL, countsSQL, filterSQL } = this.generate();
+        // Determine output directory
+        const outputDir = options.outputDir || path.join(process.cwd(), 'supabase', 'migrations');
+        // Ensure output directory exists
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+        }
+        // Generate timestamps (1 second apart to ensure unique)
+        const resultsTimestamp = generateTimestamp(0);
+        const countsTimestamp = generateTimestamp(1);
+        // Generate filenames (use config names if provided, otherwise fallback to tableName)
+        const resultsRpcName = this.config.resultsRpcName || `get_${this.config.tableName}_results`;
+        const countsRpcName = this.config.countsRpcName || `get_${this.config.tableName}_counts`;
+        const resultsFile = path.join(outputDir, `${resultsTimestamp}_${resultsRpcName}.sql`);
+        const countsFile = path.join(outputDir, `${countsTimestamp}_${countsRpcName}.sql`);
+        // Check if files exist (unless force is true)
+        if (!options.force) {
+            if (fs.existsSync(resultsFile)) {
+                throw new Error(`Results migration already exists: ${resultsFile}\nUse --force to overwrite`);
+            }
+            if (fs.existsSync(countsFile)) {
+                throw new Error(`Counts migration already exists: ${countsFile}\nUse --force to overwrite`);
+            }
+        }
+        // Write files
+        fs.writeFileSync(resultsFile, resultsSQL, 'utf-8');
+        fs.writeFileSync(countsFile, countsSQL, 'utf-8');
+        const result = {
+            resultsFile,
+            countsFile
+        };
+        // Optionally write legacy filter function for backwards compatibility
+        if (options.legacy && filterSQL) {
+            const filterTimestamp = generateTimestamp(2);
+            const filterRpcName = `filter_${this.config.tableName}_simple`;
+            const filterFile = path.join(outputDir, `${filterTimestamp}_${filterRpcName}.sql`);
+            if (!options.force && fs.existsSync(filterFile)) {
+                throw new Error(`Filter migration already exists: ${filterFile}\nUse --force to overwrite`);
+            }
+            fs.writeFileSync(filterFile, filterSQL, 'utf-8');
+            result.filterFile = filterFile;
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=rpc-generator.js.map