:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
// AUTO-GENERATED from products/data_warehouse/mcp/tools.yaml + OpenAPI — do not edit
import { z } from 'zod'
import type { Schemas } from '@/api/generated'
import * as orvalSchemas from '@/generated/data_warehouse/api'
import hooks_viewGet from '@/tools/dataWarehouse/viewGetHooks'
import { withToolHooks } from '@/tools/tool-hooks'
import { withPostHogUrl, type WithPostHogUrl } from '@/tools/tool-utils'
import type { Context, ToolBase, ZodObjectAny } from '@/tools/types'
const ManagedWarehouseMetricHistoryGetSchema = () => {
const DataWarehouseManagedWarehouseMonitoringTimeseriesRetrieveQueryParams =
orvalSchemas.DataWarehouseManagedWarehouseMonitoringTimeseriesRetrieveQueryParams()
return DataWarehouseManagedWarehouseMonitoringTimeseriesRetrieveQueryParams
}
const managedWarehouseMetricHistoryGet = (): ToolBase<
ReturnType<typeof ManagedWarehouseMetricHistoryGetSchema>,
Schemas.ManagedWarehouseMonitoringSeriesResponse
> => ({
name: 'managed-warehouse-metric-history-get',
schema: ManagedWarehouseMetricHistoryGetSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof ManagedWarehouseMetricHistoryGetSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.ManagedWarehouseMonitoringSeriesResponse>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/data_warehouse/managed-warehouse-monitoring-timeseries/`,
query: {
metric: params.metric,
window: params.window,
},
})
return result
},
})
const ManagedWarehouseMonitoringGetSchema = () => z.object({})
const managedWarehouseMonitoringGet = (): ToolBase<
ReturnType<typeof ManagedWarehouseMonitoringGetSchema>,
Schemas.ManagedWarehouseMonitoringSnapshotResponse
> => ({
name: 'managed-warehouse-monitoring-get',
schema: ManagedWarehouseMonitoringGetSchema(),
handler: async (context: Context, _params: z.infer<ReturnType<typeof ManagedWarehouseMonitoringGetSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.ManagedWarehouseMonitoringSnapshotResponse>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/data_warehouse/managed-warehouse-monitoring/`,
})
return result
},
})
const ManagedWarehouseTrinoMetricHistoryGetSchema = () => {
const DataWarehouseManagedWarehouseTrinoMonitoringTimeseriesRetrieveQueryParams =
orvalSchemas.DataWarehouseManagedWarehouseTrinoMonitoringTimeseriesRetrieveQueryParams()
return DataWarehouseManagedWarehouseTrinoMonitoringTimeseriesRetrieveQueryParams
}
const managedWarehouseTrinoMetricHistoryGet = (): ToolBase<
ReturnType<typeof ManagedWarehouseTrinoMetricHistoryGetSchema>,
Schemas.ManagedWarehouseMonitoringSeriesResponse
> => ({
name: 'managed-warehouse-trino-metric-history-get',
schema: ManagedWarehouseTrinoMetricHistoryGetSchema(),
handler: async (
context: Context,
params: z.infer<ReturnType<typeof ManagedWarehouseTrinoMetricHistoryGetSchema>>
) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.ManagedWarehouseMonitoringSeriesResponse>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/data_warehouse/managed-warehouse-trino-monitoring-timeseries/`,
query: {
metric: params.metric,
window: params.window,
},
})
return result
},
})
const ManagedWarehouseTrinoMonitoringGetSchema = () => z.object({})
const managedWarehouseTrinoMonitoringGet = (): ToolBase<
ReturnType<typeof ManagedWarehouseTrinoMonitoringGetSchema>,
Schemas.ManagedWarehouseTrinoMonitoringSnapshotResponse
> => ({
name: 'managed-warehouse-trino-monitoring-get',
schema: ManagedWarehouseTrinoMonitoringGetSchema(),
handler: async (
context: Context,
_params: z.infer<ReturnType<typeof ManagedWarehouseTrinoMonitoringGetSchema>>
) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.ManagedWarehouseTrinoMonitoringSnapshotResponse>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/data_warehouse/managed-warehouse-trino-monitoring/`,
})
return result
},
})
const SavedQueryColumnAnnotationsCreateSchema = () => {
const SavedQueryColumnAnnotationsCreateBody = orvalSchemas.SavedQueryColumnAnnotationsCreateBody()
return SavedQueryColumnAnnotationsCreateBody.extend({
column_name: SavedQueryColumnAnnotationsCreateBody.shape['column_name'].describe(
'Column to describe. Use an empty string to describe the view itself.'
),
})
}
const savedQueryColumnAnnotationsCreate = (): ToolBase<
ReturnType<typeof SavedQueryColumnAnnotationsCreateSchema>,
Schemas.DataWarehouseSavedQueryColumnAnnotation
> => ({
name: 'saved-query-column-annotations-create',
schema: SavedQueryColumnAnnotationsCreateSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof SavedQueryColumnAnnotationsCreateSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const body: Record<string, unknown> = {}
if (params.saved_query !== undefined) {
body['saved_query'] = params.saved_query
}
if (params.column_name !== undefined) {
body['column_name'] = params.column_name
}
if (params.description !== undefined) {
body['description'] = params.description
}
const result = await context.api.request<Schemas.DataWarehouseSavedQueryColumnAnnotation>({
method: 'POST',
path: `/api/projects/${encodeURIComponent(String(projectId))}/saved_query_column_annotations/`,
body,
})
return result
},
})
const SavedQueryColumnAnnotationsListSchema = () => {
const SavedQueryColumnAnnotationsListQueryParams = orvalSchemas.SavedQueryColumnAnnotationsListQueryParams()
return SavedQueryColumnAnnotationsListQueryParams
}
const savedQueryColumnAnnotationsList = (): ToolBase<
ReturnType<typeof SavedQueryColumnAnnotationsListSchema>,
WithPostHogUrl<Schemas.PaginatedDataWarehouseSavedQueryColumnAnnotationList>
> => ({
name: 'saved-query-column-annotations-list',
schema: SavedQueryColumnAnnotationsListSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof SavedQueryColumnAnnotationsListSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.PaginatedDataWarehouseSavedQueryColumnAnnotationList>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/saved_query_column_annotations/`,
query: {
limit: params.limit,
offset: params.offset,
saved_query_id: params.saved_query_id,
},
})
return await withPostHogUrl(context, result, '/sql')
},
})
const SqlVariablesCreateSchema = () => {
const InsightVariablesCreateBody = orvalSchemas.InsightVariablesCreateBody()
return InsightVariablesCreateBody
}
const sqlVariablesCreate = (): ToolBase<ReturnType<typeof SqlVariablesCreateSchema>, Schemas.InsightVariable> => ({
name: 'sql-variables-create',
schema: SqlVariablesCreateSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof SqlVariablesCreateSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const body: Record<string, unknown> = {}
if (params.name !== undefined) {
body['name'] = params.name
}
if (params.type !== undefined) {
body['type'] = params.type
}
if (params.default_value !== undefined) {
body['default_value'] = params.default_value
}
if (params.values !== undefined) {
body['values'] = params.values
}
if (params.is_multi !== undefined) {
body['is_multi'] = params.is_multi
}
if (params.values_query !== undefined) {
body['values_query'] = params.values_query
}
if (params.values_query_connection_id !== undefined) {
body['values_query_connection_id'] = params.values_query_connection_id
}
const result = await context.api.request<Schemas.InsightVariable>({
method: 'POST',
path: `/api/projects/${encodeURIComponent(String(projectId))}/insight_variables/`,
body,
})
return result
},
})
const SqlVariablesDeleteSchema = () => {
const InsightVariablesDestroyParams = orvalSchemas.InsightVariablesDestroyParams()
return InsightVariablesDestroyParams.omit({ project_id: true })
}
const sqlVariablesDelete = (): ToolBase<ReturnType<typeof SqlVariablesDeleteSchema>, unknown> => ({
name: 'sql-variables-delete',
schema: SqlVariablesDeleteSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof SqlVariablesDeleteSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<unknown>({
method: 'DELETE',
path: `/api/projects/${encodeURIComponent(String(projectId))}/insight_variables/${encodeURIComponent(String(params.id))}/`,
})
return result
},
})
const SqlVariablesUpdateSchema = () => {
const InsightVariablesPartialUpdateBody = orvalSchemas.InsightVariablesPartialUpdateBody()
const InsightVariablesPartialUpdateParams = orvalSchemas.InsightVariablesPartialUpdateParams()
return InsightVariablesPartialUpdateParams.omit({ project_id: true }).extend(
InsightVariablesPartialUpdateBody.shape
)
}
const sqlVariablesUpdate = (): ToolBase<ReturnType<typeof SqlVariablesUpdateSchema>, Schemas.InsightVariable> => ({
name: 'sql-variables-update',
schema: SqlVariablesUpdateSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof SqlVariablesUpdateSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const body: Record<string, unknown> = {}
if (params.name !== undefined) {
body['name'] = params.name
}
if (params.type !== undefined) {
body['type'] = params.type
}
if (params.default_value !== undefined) {
body['default_value'] = params.default_value
}
if (params.values !== undefined) {
body['values'] = params.values
}
if (params.is_multi !== undefined) {
body['is_multi'] = params.is_multi
}
if (params.values_query !== undefined) {
body['values_query'] = params.values_query
}
if (params.values_query_connection_id !== undefined) {
body['values_query_connection_id'] = params.values_query_connection_id
}
const result = await context.api.request<Schemas.InsightVariable>({
method: 'PATCH',
path: `/api/projects/${encodeURIComponent(String(projectId))}/insight_variables/${encodeURIComponent(String(params.id))}/`,
body,
})
return result
},
})
const ViewCheckIncrementalSchema = () => {
const WarehouseSavedQueriesCheckIncrementalCreateBody =
orvalSchemas.WarehouseSavedQueriesCheckIncrementalCreateBody()
return WarehouseSavedQueriesCheckIncrementalCreateBody
}
const viewCheckIncremental = (): ToolBase<
ReturnType<typeof ViewCheckIncrementalSchema>,
Schemas.IncrementalEligibility
> => ({
name: 'view-check-incremental',
schema: ViewCheckIncrementalSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof ViewCheckIncrementalSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const body: Record<string, unknown> = {}
if (params.query !== undefined) {
body['query'] = params.query
}
if (params.incremental_key !== undefined) {
body['incremental_key'] = params.incremental_key
}
if (params.unique_key !== undefined) {
body['unique_key'] = params.unique_key
}
if (params.lookback_seconds !== undefined) {
body['lookback_seconds'] = params.lookback_seconds
}
const result = await context.api.request<Schemas.IncrementalEligibility>({
method: 'POST',
path: `/api/projects/${encodeURIComponent(String(projectId))}/warehouse_saved_queries/check_incremental/`,
body,
})
return result
},
})
const ViewCreateSchema = () => {
const WarehouseSavedQueriesCreateBody = orvalSchemas.WarehouseSavedQueriesCreateBody()
return WarehouseSavedQueriesCreateBody.extend({
name: WarehouseSavedQueriesCreateBody.shape['name'].describe(
'Unique name for the view. Used as the table name in HogQL queries. Must not conflict with existing table names.'
),
})
}
const viewCreate = (): ToolBase<
ReturnType<typeof ViewCreateSchema>,
WithPostHogUrl<Schemas.DataWarehouseSavedQuery>
> => ({
name: 'view-create',
schema: ViewCreateSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof ViewCreateSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const body: Record<string, unknown> = {}
if (params.name !== undefined) {
body['name'] = params.name
}
if (params.query !== undefined) {
body['query'] = params.query
}
if (params.incremental !== undefined) {
body['incremental'] = params.incremental
}
if (params.description !== undefined) {
body['description'] = params.description
}
if (params.sync_frequency !== undefined) {
body['sync_frequency'] = params.sync_frequency
}
if (params.folder_id !== undefined) {
body['folder_id'] = params.folder_id
}
if (params.is_test !== undefined) {
body['is_test'] = params.is_test
}
const result = await context.api.request<Schemas.DataWarehouseSavedQuery>({
method: 'POST',
path: `/api/projects/${encodeURIComponent(String(projectId))}/warehouse_saved_queries/`,
body,
})
return await withPostHogUrl(context, result, `/sql?open_view=${result.id}`)
},
})
const ViewDeleteSchema = () => {
const WarehouseSavedQueriesDestroyParams = orvalSchemas.WarehouseSavedQueriesDestroyParams()
return WarehouseSavedQueriesDestroyParams.omit({ project_id: true })
}
const viewDelete = (): ToolBase<ReturnType<typeof ViewDeleteSchema>, unknown> => ({
name: 'view-delete',
schema: ViewDeleteSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof ViewDeleteSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<unknown>({
method: 'DELETE',
path: `/api/projects/${encodeURIComponent(String(projectId))}/warehouse_saved_queries/${encodeURIComponent(String(params.id))}/`,
})
return result
},
})
const ViewGetSchema = () => {
const WarehouseSavedQueriesRetrieveParams = orvalSchemas.WarehouseSavedQueriesRetrieveParams()
return WarehouseSavedQueriesRetrieveParams.omit({ project_id: true })
}
const viewGet = (): ToolBase<ReturnType<typeof ViewGetSchema>, WithPostHogUrl<Schemas.DataWarehouseSavedQuery>> => ({
name: 'view-get',
schema: ViewGetSchema(),
handler: withToolHooks(
hooks_viewGet,
async (context: Context, params: z.infer<ReturnType<typeof ViewGetSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.DataWarehouseSavedQuery>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/warehouse_saved_queries/${encodeURIComponent(String(params.id))}/`,
})
return await withPostHogUrl(context, result, `/sql?open_view=${result.id}`)
}
),
})
const ViewListSchema = () => {
const WarehouseSavedQueriesListQueryParams = orvalSchemas.WarehouseSavedQueriesListQueryParams()
return WarehouseSavedQueriesListQueryParams
}
const viewList = (): ToolBase<
ReturnType<typeof ViewListSchema>,
WithPostHogUrl<Schemas.PaginatedDataWarehouseSavedQueryMinimalList>
> => ({
name: 'view-list',
schema: ViewListSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof ViewListSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.PaginatedDataWarehouseSavedQueryMinimalList>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/warehouse_saved_queries/`,
query: {
include_columns: params.include_columns,
page: params.page,
search: params.search,
},
})
return await withPostHogUrl(
context,
{
...result,
results: await Promise.all(
(result.results ?? []).map((item) => withPostHogUrl(context, item, `/sql?open_view=${item.id}`))
),
},
'/sql'
)
},
})
const ViewMaterializeSchema = () => {
const WarehouseSavedQueriesMaterializeCreateBody = orvalSchemas.WarehouseSavedQueriesMaterializeCreateBody()
const WarehouseSavedQueriesMaterializeCreateParams = orvalSchemas.WarehouseSavedQueriesMaterializeCreateParams()
return WarehouseSavedQueriesMaterializeCreateParams.omit({ project_id: true }).extend(
WarehouseSavedQueriesMaterializeCreateBody.shape
)
}
const viewMaterialize = (): ToolBase<ReturnType<typeof ViewMaterializeSchema>, unknown> => ({
name: 'view-materialize',
schema: ViewMaterializeSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof ViewMaterializeSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const body: Record<string, unknown> = {}
if (params.sync_frequency !== undefined) {
body['sync_frequency'] = params.sync_frequency
}
const result = await context.api.request<unknown>({
method: 'POST',
path: `/api/projects/${encodeURIComponent(String(projectId))}/warehouse_saved_queries/${encodeURIComponent(String(params.id))}/materialize/`,
body,
})
return await withPostHogUrl(context, result, `/sql?open_view=${params.id}`)
},
})
const ViewResumeSchema = () => {
const WarehouseSavedQueriesResumeCreateBody = orvalSchemas.WarehouseSavedQueriesResumeCreateBody()
const WarehouseSavedQueriesResumeCreateParams = orvalSchemas.WarehouseSavedQueriesResumeCreateParams()
return WarehouseSavedQueriesResumeCreateParams.omit({ project_id: true }).extend(
WarehouseSavedQueriesResumeCreateBody.shape
)
}
const viewResume = (): ToolBase<ReturnType<typeof ViewResumeSchema>, WithPostHogUrl<Schemas.SavedQueryResume>> => ({
name: 'view-resume',
schema: ViewResumeSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof ViewResumeSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const body: Record<string, unknown> = {}
if (params.engine !== undefined) {
body['engine'] = params.engine
}
const result = await context.api.request<Schemas.SavedQueryResume>({
method: 'POST',
path: `/api/projects/${encodeURIComponent(String(projectId))}/warehouse_saved_queries/${encodeURIComponent(String(params.id))}/resume/`,
body,
})
return await withPostHogUrl(context, result, `/sql?open_view=${params.id}`)
},
})
const ViewRunSchema = () => {
const WarehouseSavedQueriesRunCreateBody = orvalSchemas.WarehouseSavedQueriesRunCreateBody()
const WarehouseSavedQueriesRunCreateParams = orvalSchemas.WarehouseSavedQueriesRunCreateParams()
return WarehouseSavedQueriesRunCreateParams.omit({ project_id: true }).extend(
WarehouseSavedQueriesRunCreateBody.shape
)
}
const viewRun = (): ToolBase<ReturnType<typeof ViewRunSchema>, WithPostHogUrl<Schemas.SavedQueryRunResponse>> => ({
name: 'view-run',
schema: ViewRunSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof ViewRunSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const body: Record<string, unknown> = {}
if (params.full_refresh !== undefined) {
body['full_refresh'] = params.full_refresh
}
if (params.direction !== undefined) {
body['direction'] = params.direction
}
if (params.engine !== undefined) {
body['engine'] = params.engine
}
const result = await context.api.request<Schemas.SavedQueryRunResponse>({
method: 'POST',
path: `/api/projects/${encodeURIComponent(String(projectId))}/warehouse_saved_queries/${encodeURIComponent(String(params.id))}/run/`,
body,
})
return await withPostHogUrl(context, result, `/sql?open_view=${params.id}`)
},
})
const ViewRunHistorySchema = () => {
const WarehouseSavedQueriesRunHistoryRetrieveParams = orvalSchemas.WarehouseSavedQueriesRunHistoryRetrieveParams()
return WarehouseSavedQueriesRunHistoryRetrieveParams.omit({ project_id: true })
}
const viewRunHistory = (): ToolBase<
ReturnType<typeof ViewRunHistorySchema>,
WithPostHogUrl<Schemas.DataWarehouseSavedQuery>
> => ({
name: 'view-run-history',
schema: ViewRunHistorySchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof ViewRunHistorySchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.DataWarehouseSavedQuery>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/warehouse_saved_queries/${encodeURIComponent(String(params.id))}/run_history/`,
})
return await withPostHogUrl(context, result, `/sql?open_view=${params.id}`)
},
})
const ViewUnmaterializeSchema = () => {
const WarehouseSavedQueriesRevertMaterializationCreateBody =
orvalSchemas.WarehouseSavedQueriesRevertMaterializationCreateBody()
const WarehouseSavedQueriesRevertMaterializationCreateParams =
orvalSchemas.WarehouseSavedQueriesRevertMaterializationCreateParams()
return WarehouseSavedQueriesRevertMaterializationCreateParams.omit({ project_id: true }).extend(
WarehouseSavedQueriesRevertMaterializationCreateBody.shape
)
}
const viewUnmaterialize = (): ToolBase<
ReturnType<typeof ViewUnmaterializeSchema>,
WithPostHogUrl<Schemas.DataWarehouseSavedQuery>
> => ({
name: 'view-unmaterialize',
schema: ViewUnmaterializeSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof ViewUnmaterializeSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const body: Record<string, unknown> = {}
if (params.name !== undefined) {
body['name'] = params.name
}
if (params.query !== undefined) {
body['query'] = params.query
}
if (params.incremental !== undefined) {
body['incremental'] = params.incremental
}
if (params.description !== undefined) {
body['description'] = params.description
}
if (params.sync_frequency !== undefined) {
body['sync_frequency'] = params.sync_frequency
}
if (params.folder_id !== undefined) {
body['folder_id'] = params.folder_id
}
if (params.edited_history_id !== undefined) {
body['edited_history_id'] = params.edited_history_id
}
if (params.soft_update !== undefined) {
body['soft_update'] = params.soft_update
}
if (params.is_test !== undefined) {
body['is_test'] = params.is_test
}
const result = await context.api.request<Schemas.DataWarehouseSavedQuery>({
method: 'POST',
path: `/api/projects/${encodeURIComponent(String(projectId))}/warehouse_saved_queries/${encodeURIComponent(String(params.id))}/revert_materialization/`,
body,
})
return await withPostHogUrl(context, result, `/sql?open_view=${params.id}`)
},
})
const ViewUpdateSchema = () => {
const WarehouseSavedQueriesPartialUpdateBody = orvalSchemas.WarehouseSavedQueriesPartialUpdateBody()
const WarehouseSavedQueriesPartialUpdateParams = orvalSchemas.WarehouseSavedQueriesPartialUpdateParams()
return WarehouseSavedQueriesPartialUpdateParams.omit({ project_id: true })
.extend(WarehouseSavedQueriesPartialUpdateBody.shape)
.extend({
name: WarehouseSavedQueriesPartialUpdateBody.shape['name'].describe(
'Unique name for the view. Used as the table name in HogQL queries. Must not conflict with existing table names.'
),
edited_history_id: WarehouseSavedQueriesPartialUpdateBody.shape['edited_history_id'].describe(
'Required when updating the query field. Get this from latest_history_id on the retrieve response. Used for optimistic concurrency control.'
),
})
}
const viewUpdate = (): ToolBase<
ReturnType<typeof ViewUpdateSchema>,
WithPostHogUrl<Schemas.DataWarehouseSavedQuery>
> => ({
name: 'view-update',
schema: ViewUpdateSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof ViewUpdateSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const body: Record<string, unknown> = {}
if (params.name !== undefined) {
body['name'] = params.name
}
if (params.query !== undefined) {
body['query'] = params.query
}
if (params.incremental !== undefined) {
body['incremental'] = params.incremental
}
if (params.description !== undefined) {
body['description'] = params.description
}
if (params.sync_frequency !== undefined) {
body['sync_frequency'] = params.sync_frequency
}
if (params.folder_id !== undefined) {
body['folder_id'] = params.folder_id
}
if (params.edited_history_id !== undefined) {
body['edited_history_id'] = params.edited_history_id
}
if (params.is_test !== undefined) {
body['is_test'] = params.is_test
}
const result = await context.api.request<Schemas.DataWarehouseSavedQuery>({
method: 'PATCH',
path: `/api/projects/${encodeURIComponent(String(projectId))}/warehouse_saved_queries/${encodeURIComponent(String(params.id))}/`,
body,
})
return await withPostHogUrl(context, result, `/sql?open_view=${result.id}`)
},
})
const WarehouseColumnAnnotationsCreateSchema = () => {
const WarehouseColumnAnnotationsCreateBody = orvalSchemas.WarehouseColumnAnnotationsCreateBody()
return WarehouseColumnAnnotationsCreateBody.extend({
column_name: WarehouseColumnAnnotationsCreateBody.shape['column_name'].describe(
'Column to describe. Use an empty string to describe the table itself.'
),
})
}
const warehouseColumnAnnotationsCreate = (): ToolBase<
ReturnType<typeof WarehouseColumnAnnotationsCreateSchema>,
Schemas.WarehouseColumnAnnotation
> => ({
name: 'warehouse-column-annotations-create',
schema: WarehouseColumnAnnotationsCreateSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WarehouseColumnAnnotationsCreateSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const body: Record<string, unknown> = {}
if (params.table !== undefined) {
body['table'] = params.table
}
if (params.column_name !== undefined) {
body['column_name'] = params.column_name
}
if (params.description !== undefined) {
body['description'] = params.description
}
const result = await context.api.request<Schemas.WarehouseColumnAnnotation>({
method: 'POST',
path: `/api/projects/${encodeURIComponent(String(projectId))}/warehouse_column_annotations/`,
body,
})
return result
},
})
const WarehouseColumnAnnotationsListSchema = () => {
const WarehouseColumnAnnotationsListQueryParams = orvalSchemas.WarehouseColumnAnnotationsListQueryParams()
return WarehouseColumnAnnotationsListQueryParams
}
const warehouseColumnAnnotationsList = (): ToolBase<
ReturnType<typeof WarehouseColumnAnnotationsListSchema>,
WithPostHogUrl<Schemas.PaginatedWarehouseColumnAnnotationList>
> => ({
name: 'warehouse-column-annotations-list',
schema: WarehouseColumnAnnotationsListSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WarehouseColumnAnnotationsListSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.PaginatedWarehouseColumnAnnotationList>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/warehouse_column_annotations/`,
query: {
limit: params.limit,
offset: params.offset,
table_id: params.table_id,
},
})
return await withPostHogUrl(context, result, '/sql')
},
})
const WarehouseColumnAnnotationsPartialUpdateSchema = () => {
const WarehouseColumnAnnotationsPartialUpdateBody = orvalSchemas.WarehouseColumnAnnotationsPartialUpdateBody()
const WarehouseColumnAnnotationsPartialUpdateParams = orvalSchemas.WarehouseColumnAnnotationsPartialUpdateParams()
return WarehouseColumnAnnotationsPartialUpdateParams.omit({ project_id: true }).extend(
WarehouseColumnAnnotationsPartialUpdateBody.shape
)
}
const warehouseColumnAnnotationsPartialUpdate = (): ToolBase<
ReturnType<typeof WarehouseColumnAnnotationsPartialUpdateSchema>,
Schemas.WarehouseColumnAnnotation
> => ({
name: 'warehouse-column-annotations-partial-update',
schema: WarehouseColumnAnnotationsPartialUpdateSchema(),
handler: async (
context: Context,
params: z.infer<ReturnType<typeof WarehouseColumnAnnotationsPartialUpdateSchema>>
) => {
const projectId = await context.stateManager.getProjectId()
const body: Record<string, unknown> = {}
if (params.table !== undefined) {
body['table'] = params.table
}
if (params.column_name !== undefined) {
body['column_name'] = params.column_name
}
if (params.description !== undefined) {
body['description'] = params.description
}
const result = await context.api.request<Schemas.WarehouseColumnAnnotation>({
method: 'PATCH',
path: `/api/projects/${encodeURIComponent(String(projectId))}/warehouse_column_annotations/${encodeURIComponent(String(params.id))}/`,
body,
})
return result
},
})
const WarehouseTablesRefreshSchemaCreateSchema = () => {
const WarehouseTablesRefreshSchemaCreateParams = orvalSchemas.WarehouseTablesRefreshSchemaCreateParams()
return WarehouseTablesRefreshSchemaCreateParams.omit({ project_id: true })
}
const warehouseTablesRefreshSchemaCreate = (): ToolBase<
ReturnType<typeof WarehouseTablesRefreshSchemaCreateSchema>,
unknown
> => ({
name: 'warehouse-tables-refresh-schema-create',
schema: WarehouseTablesRefreshSchemaCreateSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WarehouseTablesRefreshSchemaCreateSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<unknown>({
method: 'POST',
path: `/api/projects/${encodeURIComponent(String(projectId))}/warehouse_tables/${encodeURIComponent(String(params.id))}/refresh_schema/`,
})
return result
},
})
export const GENERATED_TOOLS: Record<string, () => ToolBase<ZodObjectAny>> = {
'managed-warehouse-metric-history-get': managedWarehouseMetricHistoryGet,
'managed-warehouse-monitoring-get': managedWarehouseMonitoringGet,
'managed-warehouse-trino-metric-history-get': managedWarehouseTrinoMetricHistoryGet,
'managed-warehouse-trino-monitoring-get': managedWarehouseTrinoMonitoringGet,
'saved-query-column-annotations-create': savedQueryColumnAnnotationsCreate,
'saved-query-column-annotations-list': savedQueryColumnAnnotationsList,
'sql-variables-create': sqlVariablesCreate,
'sql-variables-delete': sqlVariablesDelete,
'sql-variables-update': sqlVariablesUpdate,
'view-check-incremental': viewCheckIncremental,
'view-create': viewCreate,
'view-delete': viewDelete,
'view-get': viewGet,
'view-list': viewList,
'view-materialize': viewMaterialize,
'view-resume': viewResume,
'view-run': viewRun,
'view-run-history': viewRunHistory,
'view-unmaterialize': viewUnmaterialize,
'view-update': viewUpdate,
'warehouse-column-annotations-create': warehouseColumnAnnotationsCreate,
'warehouse-column-annotations-list': warehouseColumnAnnotationsList,
'warehouse-column-annotations-partial-update': warehouseColumnAnnotationsPartialUpdate,
'warehouse-tables-refresh-schema-create': warehouseTablesRefreshSchemaCreate,
}