Merge branch 'master' into fix-icon-opacity

ee/clickhouse/materialized_columns/columns.py

@@ -44,7 +44,6 @@ def get_materialized_columns(
         WHERE database = %(database)s
           AND table = %(table)s
           AND comment LIKE '%%column_materializer::%%'
-          AND comment not LIKE '%%column_materializer::elements_chain::%%'
     """,
         {"database": CLICKHOUSE_DATABASE, "table": table},
     )

frontend/src/lib/api.ts

@@ -1630,8 +1630,8 @@ const api = {
     },
 
     hogFunctions: {
-        async list(): Promise<PaginatedResponse<HogFunctionType>> {
-            return await new ApiRequest().hogFunctions().get()
+        async list(params?: { filters?: any }): Promise<PaginatedResponse<HogFunctionType>> {
+            return await new ApiRequest().hogFunctions().withQueryString(params).get()
         },
         async get(id: HogFunctionType['id']): Promise<HogFunctionType> {
             return await new ApiRequest().hogFunction(id).get()

frontend/src/lib/components/AddToDashboard/addToDashboardModalLogic.ts

@@ -21,7 +21,7 @@ export const addToDashboardModalLogic = kea<addToDashboardModalLogicType>([
     key(keyForInsightLogicProps('new')),
     path((key) => ['lib', 'components', 'AddToDashboard', 'saveToDashboardModalLogic', key]),
     connect((props: InsightLogicProps) => ({
-        values: [insightLogic(props), ['queryBasedInsight', 'legacyInsight']],
+        values: [insightLogic(props), ['queryBasedInsight']],
         actions: [
             insightLogic(props),
             ['updateInsight', 'updateInsightSuccess', 'updateInsightFailure'],
@@ -101,7 +101,9 @@ export const addToDashboardModalLogic = kea<addToDashboardModalLogicType>([
             // TODO be able to update not by patching `dashboards` against insight
             // either patch dashboard_tiles on the insight or add a dashboard_tiles API
             actions.updateInsight(
-                { ...values.legacyInsight, dashboards: [...(values.legacyInsight.dashboards || []), dashboardId] },
+                {
+                    dashboards: [...(values.queryBasedInsight.dashboards || []), dashboardId],
+                },
                 () => {
                     actions.reportSavedInsightToDashboard()
                     dashboardsModel.actions.tileAddedToDashboard(dashboardId)
@@ -117,9 +119,8 @@ export const addToDashboardModalLogic = kea<addToDashboardModalLogicType>([
         removeFromDashboard: async ({ dashboardId }): Promise<void> => {
             actions.updateInsight(
                 {
-                    ...values.legacyInsight,
-                    dashboards: (values.legacyInsight.dashboards || []).filter((d) => d !== dashboardId),
-                    dashboard_tiles: (values.legacyInsight.dashboard_tiles || []).filter(
+                    dashboards: (values.queryBasedInsight.dashboards || []).filter((d) => d !== dashboardId),
+                    dashboard_tiles: (values.queryBasedInsight.dashboard_tiles || []).filter(
                         (dt) => dt.dashboard_id !== dashboardId
                     ),
                 },

frontend/src/lib/components/Cards/TextCard/TextCard.stories.tsx

@@ -27,8 +27,6 @@ const makeTextTile = (body: string, color: InsightColor | null = null): Dashboar
 
         layouts: {},
         color,
-        last_refresh: null,
-        next_allowed_client_refresh: null,
     }
 }
 

frontend/src/models/dashboardsModel.tsx

@@ -31,26 +31,10 @@ export const dashboardsModel = kea<dashboardsModelType>([
         // can provide extra dashboard ids if not all listeners will choose to respond to this action
         // not providing a dashboard id is a signal that only listeners in the item.dashboards array should respond
         // specifying `number` not `Pick<DashboardType, 'id'> because kea typegen couldn't figure out the import in `savedInsightsLogic`
-        // if an update is made against an insight it will hold last_refresh, color, and filters_hash in dashboard context
-        updateDashboardInsight: (
-            insight: InsightModel,
-            extraDashboardIds?: number[],
-            updateTileOnDashboards?: [number]
-        ) => ({
+        // if an update is made against an insight it will hold color in dashboard context
+        updateDashboardInsight: (insight: InsightModel, extraDashboardIds?: number[]) => ({
             insight,
             extraDashboardIds,
-            updateTileOnDashboards,
-        }),
-        // a side effect on this action exists in dashboardLogic so that individual refresh statuses can be bubbled up
-        // to dashboard items in dashboards
-        updateDashboardRefreshStatus: (
-            shortId: string | undefined | null,
-            refreshing: boolean | null,
-            last_refresh: string | null
-        ) => ({
-            shortId,
-            refreshing,
-            last_refresh,
         }),
         pinDashboard: (id: number, source: DashboardEventSource) => ({ id, source }),
         unpinDashboard: (id: number, source: DashboardEventSource) => ({ id, source }),

frontend/src/queries/nodes/HogQLX/render.tsx

@@ -1,3 +1,4 @@
+import { Link } from '@posthog/lemon-ui'
 import { JSONViewer } from 'lib/components/JSONViewer'
 import { Sparkline } from 'lib/components/Sparkline'
 
@@ -37,6 +38,29 @@ export function renderHogQLX(value: any): JSX.Element {
                     <Sparkline {...props} data={data ?? []} type={type} />
                 </ErrorBoundary>
             )
+        } else if (tag === 'a') {
+            const { href, source, target } = rest
+            return (
+                <ErrorBoundary>
+                    <Link to={href} target={target ?? '_self'}>
+                        {source ? renderHogQLX(source) : href}
+                    </Link>
+                </ErrorBoundary>
+            )
+        } else if (tag === 'strong') {
+            const { source } = rest
+            return (
+                <ErrorBoundary>
+                    <strong>{renderHogQLX(source)}</strong>
+                </ErrorBoundary>
+            )
+        } else if (tag === 'em') {
+            const { source } = rest
+            return (
+                <ErrorBoundary>
+                    <em>{renderHogQLX(source)}</em>
+                </ErrorBoundary>
+            )
         }
         return <div>Unknown tag: {String(tag)}</div>
     }

frontend/src/queries/nodes/InsightQuery/utils/filtersToQueryNode.test.ts

@@ -409,6 +409,112 @@ describe('filtersToQueryNode', () => {
             }
             expect(result).toEqual(query)
         })
+
+        it('converts multiple breakdowns', () => {
+            const filters: Partial<TrendsFilterType> = {
+                insight: InsightType.TRENDS,
+                breakdowns: [
+                    {
+                        type: 'event',
+                        property: '$pathname',
+                        normalize_url: true,
+                    },
+                    {
+                        type: 'group',
+                        property: '$num',
+                        group_type_index: 0,
+                        histogram_bin_count: 10,
+                    },
+                ],
+            }
+
+            const result = filtersToQueryNode(filters)
+
+            const query: TrendsQuery = {
+                kind: NodeKind.TrendsQuery,
+                breakdownFilter: {
+                    breakdowns: [
+                        {
+                            type: 'event',
+                            property: '$pathname',
+                            normalize_url: true,
+                        },
+                        {
+                            type: 'group',
+                            property: '$num',
+                            group_type_index: 0,
+                            histogram_bin_count: 10,
+                        },
+                    ],
+                },
+                series: [],
+            }
+            expect(result).toEqual(query)
+        })
+
+        it('converts legacy funnel breakdowns', () => {
+            const filters: Partial<TrendsFilterType> = {
+                insight: InsightType.TRENDS,
+                breakdowns: [
+                    {
+                        type: 'event',
+                        property: '$current_url',
+                    },
+                    {
+                        property: '$pathname',
+                    } as any,
+                ],
+            }
+
+            const result = filtersToQueryNode(filters)
+
+            const query: TrendsQuery = {
+                kind: NodeKind.TrendsQuery,
+                breakdownFilter: {
+                    breakdowns: [
+                        {
+                            type: 'event',
+                            property: '$current_url',
+                        },
+                        {
+                            type: 'event',
+                            property: '$pathname',
+                        },
+                    ],
+                },
+                series: [],
+            }
+            expect(result).toEqual(query)
+        })
+
+        it('does not add breakdown_type for multiple breakdowns', () => {
+            const filters: Partial<TrendsFilterType> = {
+                insight: InsightType.TRENDS,
+                breakdowns: [
+                    {
+                        type: 'person',
+                        property: '$browser',
+                    },
+                ],
+            }
+
+            const result = filtersToQueryNode(filters)
+
+            const query: TrendsQuery = {
+                kind: NodeKind.TrendsQuery,
+                breakdownFilter: {
+                    breakdowns: [
+                        {
+                            type: 'person',
+                            property: '$browser',
+                        },
+                    ],
+                    breakdown_type: undefined,
+                },
+                series: [],
+            }
+            expect(result).toEqual(query)
+        })
     })
 
     describe('funnels filter', () => {

frontend/src/queries/nodes/InsightQuery/utils/filtersToQueryNode.ts

@@ -296,22 +296,34 @@ export const filtersToQueryNode = (filters: Partial<FilterType>): InsightQueryNo
 
     // breakdown
     if (isInsightQueryWithBreakdown(query)) {
-        /* handle multi-breakdowns */
         // not undefined or null
         if (filters.breakdowns != null) {
-            if (filters.breakdowns.length === 1) {
-                filters.breakdown_type = filters.breakdowns[0].type
-                filters.breakdown = filters.breakdowns[0].property as string
-            } else {
-                captureException(
-                    'Could not convert multi-breakdown property `breakdowns` - found more than one breakdown'
-                )
+            /* handle multi-breakdowns for funnels */
+            if (isFunnelsFilter(filters)) {
+                if (filters.breakdowns.length === 1) {
+                    filters.breakdown_type = filters.breakdowns[0].type || 'event'
+                    filters.breakdown = filters.breakdowns[0].property as string
+                } else {
+                    captureException(
+                        'Could not convert multi-breakdown property `breakdowns` - found more than one breakdown'
+                    )
+                }
             }
-        }
 
-        /* handle missing breakdown_type */
-        // check for undefined and null values
-        if (filters.breakdown != null && filters.breakdown_type == null) {
+            /* handle multi-breakdowns for trends */
+            if (isTrendsFilter(filters)) {
+                filters.breakdowns = filters.breakdowns.map((b) => ({
+                    ...b,
+                    // Compatibility with legacy funnel breakdowns when someone switches a view from funnels to trends
+                    type: b.type || filters.breakdown_type || 'event',
+                }))
+            }
+        } else if (
+            /* handle missing breakdown_type */
+            // check for undefined and null values
+            filters.breakdown != null &&
+            filters.breakdown_type == null
+        ) {
             filters.breakdown_type = 'event'
         }
 

frontend/src/queries/schema.json

@@ -7669,6 +7669,7 @@
                     "type": "integer"
                 },
                 "end_time": {
+                    "description": "When did the query execution task finish (whether successfully or not).",
                     "format": "date-time",
                     "type": "string"
                 },
@@ -7697,6 +7698,11 @@
                     },
                     "type": "array"
                 },
+                "pickup_time": {
+                    "description": "When was the query execution task picked up by a worker.",
+                    "format": "date-time",
+                    "type": "string"
+                },
                 "query_async": {
                     "const": true,
                     "default": true,
@@ -7708,6 +7714,7 @@
                 },
                 "results": {},
                 "start_time": {
+                    "description": "When was query execution task enqueued.",
                     "format": "date-time",
                     "type": "string"
                 },

frontend/src/queries/schema.ts

@@ -1079,9 +1079,11 @@ export type QueryStatus = {
     /**  @default null */
     error_message: string | null
     results?: any
-    /**  @format date-time */
+    /** When was the query execution task picked up by a worker. @format date-time */
+    pickup_time?: string
+    /** When was query execution task enqueued. @format date-time */
     start_time?: string
-    /**  @format date-time */
+    /** When did the query execution task finish (whether successfully or not). @format date-time */
     end_time?: string
     /**  @format date-time */
     expiration_time?: string

frontend/src/scenes/actions/Action.stories.tsx

@@ -75,7 +75,6 @@ const meta: Meta = {
             get: {
                 '/api/projects/:team_id/actions/': toPaginatedResponse([MOCK_ACTION]),
                 '/api/projects/:team_id/actions/1/': MOCK_ACTION,
-                '/api/projects/:team_id/actions/1/plugin_configs': toPaginatedResponse([]),
             },
         }),
     ],

frontend/src/scenes/actions/Action.tsx

@@ -11,6 +11,7 @@ import { NodeKind } from '~/queries/schema'
 import { ActionType } from '~/types'
 
 import { ActionEdit } from './ActionEdit'
+import { ActionHogFunctions } from './ActionHogFunctions'
 
 export const scene: SceneExport = {
     logic: actionLogic,
@@ -44,6 +45,7 @@ export function Action({ id }: { id?: ActionType['id'] } = {}): JSX.Element {
     return (
         <>
             <ActionEdit id={id} action={action} />
+            <ActionHogFunctions />
             {id && (
                 <>
                     {isComplete ? (